import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.io.Serializable;

@Entity
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (id != null ? id.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof User)) {
            return false;
        }
        User other = (User) object;
        if ((this.id == null && other.id != null) || (this.id != null && !this.id.equals(other.id))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "src.User[ id=" + id + " ]";
    }
}

import java.util.List;

public interface UserDao {

    public List<User> getAllUsers();

}

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
@Component
public class UserDaoImpl implements UserDao {
    @Override
    public List<User> getAllUsers() {
        return null;
    }
}

public class UserProvider {

// здесь будут разные методы, возвращающие листы данных по тем или иным параметрам.

}

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
public class UserController {

    private static final Logger log = Logger.getLogger(UserController.class);
    private UserDao userDao;

    @Autowired
    public UserController(UserDao userDao) {
        this.userDao = userDao;
    }

    @RequestMapping(value = "/users", method = RequestMethod.GET)
    @ResponseBody
    public List<User> getAllUsers() {
//        List<User> usersList =
        return null;
    }
}

         <properties>
               <spring.version>5.0.3.RELEASE</spring.version>
        </properties>

       <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.0.3.RELEASE</version>
        </dependency>

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
             http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
             version="2.1">

    <persistence-unit name="PU" transaction-type="RESOURCE_LOCAL">
        <!--/////// это юзаем когда создаем entityManagerFactory.createEntityManager(); из HibernateUtil -->
        <!--<non-jta-data-source>java:comp/env/jdbc/postgres</non-jta-data-source>-->
        <!-- а если нужны логи...-->
        <non-jta-data-source>java:comp/env/jdbc/postgresLogged</non-jta-data-source>
        <!--///////-->
        <properties>

            <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQL95Dialect"/> <!-- DB Dialect -->
            <property name="hibernate.hbm2ddl.auto" value="update" /> <!-- create / create-drop / update -->
            <property name="hibernate.show_sql" value="false"/>
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.physical_naming_strategy" value="com.opalev.config.PhysicalNamingStrategyImpl"/>

            <property name="hibernate.jdbc.lob.non_contextual_creation" value="true"/>
        </properties>
    </persistence-unit>

</persistence>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.opalev</groupId>
    <artifactId>ph</artifactId>
    <packaging>war</packaging>
    <version>3.0-SNAPSHOT</version>

    <properties>
        <hibernate.version>5.2.12.Final</hibernate.version>
        <spring.version>5.0.3.RELEASE</spring.version>
        <log4j.version>1.2.17</log4j.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java-version>1.8</java-version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>2.0.3.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.3</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
        </dependency>

        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-dbcp2 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.1</version>
        </dependency>

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>9.4-1202-jdbc42</version>
            <!--версия 9.4-1202-jdbc42 подходит для postgres 10.1 jdk 1.8 -->
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.1-api -->
        <dependency>
            <groupId>org.hibernate.javax.persistence</groupId>
            <artifactId>hibernate-jpa-2.1-api</artifactId>
            <version>1.0.2.Final</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/commons-digester/commons-digester -->
        <dependency>
            <groupId>commons-digester</groupId>
            <artifactId>commons-digester</artifactId>
            <version>2.1</version>
        </dependency>

        <!-- Log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
        <!--<dependency>-->
        <!--<groupId>org.slf4j</groupId>-->
        <!--<artifactId>slf4j-api</artifactId>-->
        <!--<version>1.7.25</version>-->
        <!--</dependency>-->
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-simple -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.25</version>
            <scope>compile</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.googlecode.log4jdbc/log4jdbc -->
        <dependency>
            <groupId>com.googlecode.log4jdbc</groupId>
            <artifactId>log4jdbc</artifactId>
            <version>1.2</version>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
            <scope>provided</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>23.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.4</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java-version}</source>
                    <target>${java-version}</target>
                    <!--<compilerArgument>-Xlint:all</compilerArgument>-->
                    <compilerArgument>-Xlint:-processing</compilerArgument>
                    <showWarnings>true</showWarnings>
                    <showDeprecation>true</showDeprecation>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

import lombok.extern.log4j.Log4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

@Configuration
@EnableWebMvc
@ComponentScan("com.opalev")
@EnableJpaRepositories(basePackages = "com.opalev", entityManagerFactoryRef = "emf")
@Log4j
public class WebConfig extends WebMvcConfigurerAdapter {


    @Autowired
    private Environment environment;
    @Autowired
    private ApplicationContext applicationContext;
    private static DataSource dataSource;

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/WEB-INF/**").addResourceLocations("");
        registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
//        registry.addResourceHandler("/bootstrap/**").addResourceLocations("/resources/");
    }

    @Bean
    public InternalResourceViewResolver setupViewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/");
        resolver.setSuffix(".jsp");
        resolver.setViewClass(JstlView.class);
        return resolver;
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public HibernateUtil setupPostProcessor() {
        return new HibernateUtil();
    }

    @Bean
    public DataSource dataSource() throws NamingException {
        if (dataSource == null) {
            try {
                Context ctx = new InitialContext();
//                dataSource = (DataSource) ctx.lookup("java:comp/env/jdbc/postgres");
                dataSource = (DataSource) ctx.lookup("java:comp/env/jdbc/postgresLogged"); // если хотим логирование log4jdbc, т.е. для дева.
            } catch (NamingException e) {
                log.error("Хм.. ошибка какая-то: " + e);
            }
        }
        return dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean emf() throws NamingException {
        LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
        emf.setDataSource(dataSource());
        emf.setPersistenceUnitName("PU");
        HibernateJpaVendorAdapter hibernateJpaVendorAdapter = new HibernateJpaVendorAdapter();
        hibernateJpaVendorAdapter.setShowSql(true);
        hibernateJpaVendorAdapter.setDatabasePlatform("org.hibernate.dialect.PostgreSQL95Dialect");
        emf.setJpaVendorAdapter(hibernateJpaVendorAdapter);
        emf.setPackagesToScan("com.opalev");
        return emf;
    }

}

import org.springframework.context.annotation.Bean;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.criteria.CriteriaBuilder;
import java.io.Serializable;

public class HibernateUtil implements Serializable {

    private static final long serialVersionUID = 1L;
    private static EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("PU");

    @Bean
    public static EntityManager getEntityManager() {
        return entityManagerFactory.createEntityManager();
    }

    @Bean
    public static CriteriaBuilder getCriteriaBuilder() {
//        emf = Persistence.createEntityManagerFactory("PU");
        CriteriaBuilder builder = entityManagerFactory.getCriteriaBuilder();
        return builder;
    }
}

import lombok.EqualsAndHashCode;

import javax.persistence.*;
import java.io.Serializable;

@Entity
@EqualsAndHashCode
@Table(name = "users")
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String email;
    private String homeAddress;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getHomeAddress() {
        return homeAddress;
    }

    public void setHomeAddress(String homeAddress) {
        this.homeAddress = homeAddress;
    }

    @Override
    public String toString() {
        return "src.User[ id=" + id + " ]";
    }
}

import org.springframework.data.repository.CrudRepository;

import java.util.List;
public interface UserRepository extends CrudRepository<User, Integer> {
    List<User> findByName(String name);
}

import com.opalev.config.HibernateUtil;
import lombok.extern.log4j.Log4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;

@Controller
@Log4j
public class UserController {

    private List<User> userList = new ArrayList<>();

    @Autowired
    private UserRepository userRepository;

    @RequestMapping(value = "/usersCR", method = RequestMethod.GET)
    @ResponseBody
    public List<User> getUsersWithCriteria() {

        log.info("подтянем юзеров используя Criteria ");
        EntityManager em = HibernateUtil.getEntityManager();
        CriteriaBuilder builder = HibernateUtil.getCriteriaBuilder();
        CriteriaQuery<User> criteriaQuery = builder.createQuery(User.class);
        Root<User> usersRoot = criteriaQuery.from(User.class);
        criteriaQuery.select(usersRoot);
        criteriaQuery.where(builder.like(usersRoot.get("name"), "%admin%"));
        criteriaQuery.orderBy(builder.desc(usersRoot.get("id")));

        userList.clear();
        userList = em.createQuery(criteriaQuery).getResultList();
        log.info("userList: " + userList);
        for (User u : userList) {
            Integer id = (Integer) u.getId();
            String name = (String) u.getName();
            log.info("id:" + id + ", name:" + name);
        }
        return userList;
    }

    @RequestMapping(value = "/usersCQ", method = RequestMethod.GET)
    @ResponseBody
    public List<User> getUsersWithEntityManager() {
        System.out.println("подтянем юзеров используя createQuery ");
        EntityManager em = HibernateUtil.getEntityManager();
        try {
            Query q = em.createQuery("select u from User as u order by u.id desc");
            userList.clear();
            userList = q.getResultList();
            log.info("userList: " + userList.size());
            return userList;
        } catch (NoResultException ex) {
            log.info("exception: " + ex);
            return null;
        } finally {
            em.close();
        }
    }

    @RequestMapping(value = "/usersSData", method = RequestMethod.GET)
    @ResponseBody
    public List<User> getUserWithSpringData(@RequestParam(value = "userName", required = false) String name) {
        userList.clear();
        userList = userRepository.findByName(name);
        for (User u : userList) {
            Integer id = (Integer) u.getId();
            String userName = (String) u.getName();
            log.info("id:" + id + ", name:" + userName);
        }
        return userList;
    }

}

	 <Resource name="jdbc/postgresLogged" auth="Container"
         type="javax.sql.DataSource" driverClassName="net.sf.log4jdbc.DriverSpy"
         url="jdbc:log4jdbc:postgresql://127.0.0.1:5432/ph"
         username="user" password="12345678" maxIdle="10"/>
		 
	<Resource name="jdbc/postgres" auth="Container"
         type="javax.sql.DataSource" driverClassName="org.postgresql.Driver"
         url="jdbc:postgresql://127.0.0.1:5432/ph"
         username="user" password="12345678" maxIdle="10"/>