@Modifying
    @Query("SELECT max(s.actionDatetime), min(s.actionDatetime) FROM #{#entityName} s")
    List<Object[]> getMaxMinIdByActionDatetime();

Hibernate: 
    select
        max(shift0_.action_datetime) as col_0_0_,
        min(shift0_.action_datetime) as col_1_0_ 
    from
        shift shift0_

    Query q = em.createNativeQuery(
        "SELECT o.id AS order_id, " +
            "o.quantity AS order_quantity, " +
            "o.item AS order_item, " +
            "i.name AS item_name, " +
        "FROM Order o, Item i " +
        "WHERE (order_quantity > 25) AND (order_item = i.id)",
    "OrderResults");
    
    @SqlResultSetMapping(name="OrderResults", 
        entities={ 
            @EntityResult(entityClass=com.acme.Order.class, fields={
                @FieldResult(name="id", column="order_id"),
                @FieldResult(name="quantity", column="order_quantity"), 
                @FieldResult(name="item", column="order_item")})},
        columns={
            @ColumnResult(name="item_name")}

public class TimeInterval {
    private LocalDateTime start;
    private LocalDateTime stop;

    public TimeInterval() {
    }

    
 

    public TimeInterval(Date start, Date stop) {
        this.start = LocalDateTime.ofInstant(start.toInstant(), ZoneId.systemDefault());
        this.stop =  LocalDateTime.ofInstant(stop.toInstant(), ZoneId.systemDefault());;
    }


 @Query("SELECT new ru.model.TimeInterval(max(s.actionDatetime), min(s.actionDatetime)) FROM #{#entityName} s")
    TimeInterval getMaxMinIdByActionDatetime();

SELECT new OrderResults(max(s.actionDatetime), min(s.actionDatetime)) FROM #{#entityName};

JPA 2.1 with @SqlResultSetMapping

With the arrival of JPA 2.1, we can use the @SqlResultSetMapping annotation to solve the problem.

We need to declare a result set mapping somewhere in a entity:

@SqlResultSetMapping(name="JediResult", classes = {
    @ConstructorResult(targetClass = Jedi.class, 
    columns = {@ColumnResult(name="name"), @ColumnResult(name="age")})
})
And then we simply do:

Query query = em.createNativeQuery("SELECT name,age FROM jedis_table", "JediResult");
@SuppressWarnings("unchecked")
List<Jedi> samples = query.getResultList();
Of course, in this case Jedi needs not to be an mapped entity. It can be a regular POJO.

SELECT b.id, b.title, b.author_id, b.version, a.id as authorId, a.firstName, a.lastName, a.version as authorVersion FROM Book b JOIN Author a ON b.author_id = a.id

@SqlResultSetMapping(
        name = "BookAuthorMapping",
        entities = {
            @EntityResult(
                    entityClass = Book.class,
                    fields = {
                        @FieldResult(name = "id", column = "id"),
                        @FieldResult(name = "title", column = "title"),
                        @FieldResult(name = "author", column = "author_id"),
                        @FieldResult(name = "version", column = "version")}),
            @EntityResult(
                    entityClass = Author.class,
                    fields = {
                        @FieldResult(name = "id", column = "authorId"),
                        @FieldResult(name = "firstName", column = "firstName"),
                        @FieldResult(name = "lastName", column = "lastName"),
                        @FieldResult(name = "version", column = "authorVersion")})})

List<Object[]> results = this.em.createNativeQuery("SELECT b.id, b.title, b.author_id, b.version, a.id as authorId, a.firstName, a.lastName, a.version as authorVersion FROM Book b JOIN Author a ON b.author_id = a.id", "BookAuthorMapping").getResultList();

results.stream().forEach((record) -> {
    Book book = (Book)record[0];
    Author author = (Author)record[1];
    // do something useful
});

SELECT a.id, a.firstName, a.lastName, a.version, count(b.id) as bookCount FROM Book b JOIN Author a ON b.author_id = a.id GROUP BY a.id, a.firstName, a.lastName, a.version


@SqlResultSetMapping(
        name = "AuthorBookCountMapping",
        entities = @EntityResult(
                entityClass = Author.class,
                fields = {
                    @FieldResult(name = "id", column = "id"),
                    @FieldResult(name = "firstName", column = "firstName"),
                    @FieldResult(name = "lastName", column = "lastName"),
                    @FieldResult(name = "version", column = "version")}),
        columns = @ColumnResult(name = "bookCount", type = Long.class))


List<Object[]> results = this.em.createNativeQuery("SELECT a.id, a.firstName, a.lastName, a.version, count(b.id) as bookCount FROM Book b JOIN Author a ON b.author_id = a.id GROUP BY a.id, a.firstName, a.lastName, a.version", "AuthorBookCountMapping").getResultList();

results.stream().forEach((record) -> {
    Author author = (Author)record[0];
    Long bookCount = (Long)record[1];
    System.out.println("Author: ID ["+author.getId()+"] firstName ["+author.getFirstName()+"] lastName ["+author.getLastName()+"] number of books ["+bookCount+"]");
});

@Query("SELECT max(s.actionDatetime), min(s.actionDatetime) FROM #{#entityName} s")

@PersistenceContext
private EntityManager em;

...

public void queryWithAuthorBookCountHibernateMapping() {
  Session session = (Session)this.em.getDelegate();
  ...
}


List<BookValue> results = ((Session)this.em.getDelegate()).createSQLQuery("SELECT b.id, b.title, b.version, a.firstName || ' ' || a.lastName as authorName FROM Book b JOIN Author a ON b.author_id = a.id")
    .addScalar("id", StandardBasicTypes.LONG).addScalar("title").addScalar("version", StandardBasicTypes.LONG).addScalar("authorName")
    .setResultTransformer(new AliasToBeanResultTransformer(BookValue.class)).list();

results.stream().forEach((book) -> {
    System.out.println("Book: ID [" + book.getId() + "] title [" + book.getTitle() + "] authorName [" + book.getAuthorName() + "]");
});

@Repository
public interface EmployeeRepository extends  JpaRepository<Employee,Integer>, JpaSpecificationExecutor<Employee> {

   @Query("select e from Employee e where e.id = :id") 
   Employee findByEmployeeId(@Param("id") Integer id );
}

   @Test
    public void test1() {
        Employee employee = employeeRepository.findOne(2); //findOne(1)  подтянуть всю!!!! таблицу и все данные одни запросом !!!! Легко !?!
        System.out.println(employee);
        System.out.println(employee.getEmployees());
        System.out.println(employee.getShifts());
        
    }

Hibernate: 
    select
        employee0_.id as id1_1_0_,
        employee0_.department_id as departme4_1_0_,
        employee0_.employee_id as employee5_1_0_,
        employee0_.name as name2_1_0_,
        employee0_.salary as salary3_1_0_,
        department1_.id as id1_0_1_,
        department1_.name as name2_0_1_ 
    from
        employee employee0_ 
    inner join
        department department1_ 
            on employee0_.department_id=department1_.id 
    where
        employee0_.id=?

org.hibernate.LazyInitializationException: could not initialize proxy - no Session
	at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:165)

  @ManyToOne(fetch = FetchType.EAGER)
    private Employee employeeId;

@Service
public class EmployeeServiceImpl implements EmployeeService {

    @PersistenceContext
    private EntityManager em;
    
    
    protected final EmployeeRepository repository;

    @Autowired
    public EmployeeServiceImpl(EmployeeRepository repository) {
        super();
        this.repository = repository;
    }

    @Override
    //@Transactional
    public Employee findByEmployeeId(Integer id) {
       TypedQuery<Employee> query = em
               .createQuery("select e from Employee e  where e.id = :id ",Employee.class) //   для проверки любого запроса 
               //createQuery("select e from Employee e JOIN FETCH e.employees b JOIN FETCH e.departmentId d where e.id = :id ",Employee.class)
               .setParameter("id", id);
        return query.getSingleResult();
    }
    
}

drop table if exists department;
create table department (
      id   int          not null    AUTO_INCREMENT
    , name varchar(255) not null
    , primary key (id)
);


insert into department (
    id, name
) values
  (1, 'IT')
, (2, 'Management')
, (3, 'CTO')
;

 drop table if exists employee;
 create table employee (
   id            int             not null    auto_increment,
   department_id int             not null,
   employee_id   int,
   name          varchar(255)    not null,
   salary        bigint unsigned not null,
   primary key (id),
   constraint FK_department_id_department_id foreign key (department_id)
  references department (id),
  constraint FK_employee_id_employee_id foreign key (employee_id)
   references employee (id)
 );

 insert into employee (
     id, department_id, employee_id, name, salary
 ) values
   ( 1, 3,  null, 'Mapiro',      100000000 )
 , ( 2, 1,  1,    'Vatyushkin',    19000000 )
 , ( 3, 1,  2,    'Horin',         21000000 )
 , ( 4, 1,  3,    'Sinitsin',      12000000 )
 , ( 5, 1,  3,    'Ustovalov',    10000000 )
 , ( 6, 1,  3,    'Fox',           10000000 )
 , ( 7, 1,  6,    'Kalnikov',      14000000 )
 , ( 8, 1,  2,    'Senderov',   15000000 )
 , ( 9, 1,  8,    'Prushnikov',  10000000 )
 , (10, 1,  8,    'Zaitsev',       15000000 )
 , (11, 1,  8,    'Gulshaev',   10000000 )
 , (12, 2,  1,    'Ignotogin',       15000000 )
 , (13, 2, 12,    'Lyabovsky',     12000000 )
 , (14, 2, 12,    'Ivanova',        15500000 )
 , (15, 3,  1,    'Krasavica',      8000000 )
 , (16, 3, 15,    'Uborshik',       8500000 )
 ;

@Basic(optional = false)

@OneToMany  fetch = FetchType.LAZY optional = false nullable = false 

@org.hibernate.annotations.Fetch(FetchMode.JOIN) 

SELECT b.id, b.title, b.author_id, b.version, a.id as authorId, a.firstName, a.lastName, a.version as authorVersion FROM Book b JOIN Author a ON b.author_id = a.id

@SqlResultSetMapping(
        name = "BookAuthorMapping",
        entities = {
            @EntityResult(
                    entityClass = Book.class,
                    fields = {
                        @FieldResult(name = "id", column = "id"),
                        @FieldResult(name = "title", column = "title"),
                        @FieldResult(name = "author", column = "author_id"),
                        @FieldResult(name = "version", column = "version")}),
            @EntityResult(
                    entityClass = Author.class,
                    fields = {
                        @FieldResult(name = "id", column = "authorId"),
                        @FieldResult(name = "firstName", column = "firstName"),
                        @FieldResult(name = "lastName", column = "lastName"),

List<Object[]> results = this.em.createNativeQuery("SELECT b.id, b.title, b.author_id, b.version, a.id as authorId, a.firstName, a.lastName, a.version as authorVersion FROM Book b JOIN Author a ON b.author_id = a.id", "BookAuthorMapping").getResultList();

results.stream().forEach((record) -> {
    Book book = (Book)record[0];
    Author author = (Author)record[1];

Session session = entityManager.unwrap(Session.class);

Session session = (Session) entityManager.getDelegate();

@PersistenceContext
EntityManager entityManager;

public List<MyEntity> findSomeApples() {
  return entityManager
     .createQuery(MyEntity.class, "from MyEntity where apples=7")
     .getResultList();
}

@Autowired
SessionFactory sessionFactory;

public List<MyEntity> findSomeApples() {
  Session session = sessionFactory.getCurrentSession();
  List<?> result = session.createQuery("from MyEntity where apples=7")
      .list();
  @SuppressWarnings("unchecked")
  List<MyEntity> resultCasted = (List<MyEntity>) result;
  return resultCasted;
}

   @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
        return configurer;
    }

    @Bean
    @Qualifier("dataSource")
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("");

        dataSource.setUsername("root");
        dataSource.setPassword("root");

        return dataSource;
    }


    @Autowired
    @Bean(name = "entityManagerFactory")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(@Qualifier("dataSource") DataSource dataSource) {

        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setShowSql(true);
        

        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource);
        em.setPackagesToScan(new String[]{
            "ru.entities",});
        em.setPersistenceUnitName("testPersistanceUnit");

        em.setJpaVendorAdapter(vendorAdapter);
        em.setJpaProperties(additionalProperties());

        return em;

    }

    @Autowired
    @Bean(name = "transactionManager")
    @Qualifier("transactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("entityManagerFactory") EntityManagerFactory entityManagerFactory) {
        JpaTransactionManager txManager = new JpaTransactionManager();
        txManager.setEntityManagerFactory(entityManagerFactory);
        return txManager;
    }

    @Bean
    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
        return new PersistenceExceptionTranslationPostProcessor();
    }

 Properties additionalProperties() {
        Properties properties = new Properties();
        properties.setProperty("hibernate.bytecode.use_reflection_optimizer", "false");
        properties.setProperty("hibernate.connection.driver_class", "com.mysql.jdbc.Driver");
        properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL5InnoDBDialect");
        properties.setProperty("hibernate.hbm2ddl.auto", "validate");//update validate
        properties.setProperty("hibernate.show_sql", "true");
        properties.setProperty("hibernate.format_sql", "true");
        properties.setProperty("hibernate.connection.characterEncoding", "utf8");

        properties.setProperty("hibernate.connection.Useunicode", "true");

        properties.setProperty("hibernate.default_batch_fetch_size", "16");
        properties.setProperty("hibernate.max_fetch_depth", "3");
        properties.setProperty("hibernate.jdbc.fetch_size", "50");

        return properties;
    }

        
    @Bean(name = "sessionFactory")
    LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean();
        return sessionFactoryBean;
    }
    
    @Autowired
    @Bean(name = "transactionManager")
    @Qualifier("transactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("sessionFactory") LocalSessionFactoryBean sessionFactory) {

        HibernateTransactionManager txManager = new HibernateTransactionManager();
        txManager.setSessionFactory(sessionFactory);
        return txManager;
    }

    @Override
    @Transactional
    public Employee findOneH(Integer id) {


        Session session = (Session) em.getDelegate();//
//     session = session.getSessionFactory().getCurrentSession(); // ЗАКРЫТАЯ СЕССИЯ !!!!
        session = session.getSessionFactory().openSession(); //  так работает !!!!
        Employee employee = (Employee) session.get(Employee.class, id);
        session.close();
        return employee;
    }

Java 8 baseline
5.2 moves to Java 8 as its baseline, both for JDK and JRE. This means:

The hibernate-java8 module has been removed; that functionality has been consolidated into hibernate-core.

Native support for Java 8 date/time types as Query parameters.

Support for streaming (java.util.stream.Stream) query results.

Support for java.util.Optional as return from methods that may return null.

Leveraging Java 8 "default methods" when introducing new methods to extension points.

ntity joins (or ad hoc joins)
In HQL you now have the ability to define a join to an entity, not just a mapped association. For example:

select ...
from FinancialRecord f
    left join User u
        on r.lastUpdateBy = u.username
See HHH-16 for details.

load-by-multiple-id API
Loading multiple entities of same type by identifier is now a first class API much like loading a single entity by identifier. For example:

// load Users 1, 2 and 3 at one shot
List<User> users = session.byMultipleIds(User.class)
    .multiLoad( 1, 2, 3 );

    @Test
    public void test4() {

        final StopWatch stopWatch = new StopWatch();
        stopWatch.start("employeeService.findOne");
        Employee employee = employeeService.findOne(2);
        stopWatch.stop();
        System.out.println(employee);
        System.out.println(stopWatch.prettyPrint());
    }

@Service
@Repository
public class EmployeeServiceImpl implements EmployeeService {

    @PersistenceContext
    private EntityManager em;
    
    protected final EmployeeRepository repository;

    @Autowired
    public EmployeeServiceImpl(EmployeeRepository repository) {
        super();
        this.repository = repository;
    }


    @Override
    @Transactional(readOnly = true)
    public Employee findOne(Integer id) {
       Employee employee =  em.find(Employee.class, id);
// тут получаю       //org.hibernate.LazyInitializationException: could not initialize proxy - no Session
       employee.getDepartmentId().getId();
       employee.getEmployeeId().getId();
        int size = employee.getEmployees().size();
    
       return employee;
    }
    

  @PersistenceContext(type = PersistenceContextType.EXTENDED)
    private EntityManager em;

  @PersistenceContext
    private EntityManager em;

    select
        e.id,
        e.name,
        e.salary,
        e.department_id,
        e.employee_id     
    from
        employee e      
    WHERE
        e.id = 2 

    @Test
    @Repeat(5)
    public void test4N() {

        final StopWatch stopWatch = new StopWatch();
        stopWatch.start("mployeeService.findOnlyId");
        Employee employee = employeeService.findOnlyId(2);
        stopWatch.stop();
        System.out.println(employee);
        System.out.println(stopWatch.prettyPrint());
    }

@Override
    @Transactional(readOnly = true ,propagation = Propagation.SUPPORTS)
    public Employee findOnlyId(Integer id) {

        String sql = " select \n"
                + "         e.id, \n"
                + "         e.name,\n"
                + "         e.salary,\n"
                + "         e.department_id,\n"
                + "         e.employee_id\n"
                + "    from\n"
                + "        employee e \n"
                + "\n"
                + "   WHERE e.id = :id";


        Object[] employee = (Object[]) em.createNativeQuery(sql)
                .setParameter("id", id)
                .getSingleResult();
      
        Employee e = new Employee(
                (Integer) employee[0],
                (String) employee[1],
                ((BigInteger) employee[2]).longValue(),
                (Integer) employee[3],
                (Integer) employee[4]);
        
        return e; 

       
    }

Hibernate: 
    select
        e.id,
        e.name,
        e.salary,
        e.department_id,
        e.employee_id     
    from
        employee e      
    WHERE
        e.id = ?
июн 20, 2016 5:27:12 PM org.hibernate.engine.internal.StatisticalLoggingSessionEventListener end
INFO: Session Metrics {
    4102790 nanoseconds spent acquiring 1 JDBC connections;
    0 nanoseconds spent releasing 0 JDBC connections;
    4275069 nanoseconds spent preparing 1 JDBC statements;
    203020 nanoseconds spent executing 1 JDBC statements;
    0 nanoseconds spent executing 0 JDBC batches;
    0 nanoseconds spent performing 0 L2C puts;
    0 nanoseconds spent performing 0 L2C hits;
    0 nanoseconds spent performing 0 L2C misses;
    0 nanoseconds spent executing 0 flushes (flushing a total of 0 entities and 0 collections);
    0 nanoseconds spent executing 0 partial-flushes (flushing a total of 0 entities and 0 collections)
}
Employee{id=2, name=Matyushkin, salary=19000000, departmentId=1, employeeId=1}
StopWatch '': running time (millis) = 9
-----------------------------------------
ms     %     Task name
-----------------------------------------
00009  100%  mployeeService.findOnlyId