Recientemente he empezado a usar la Primavera de arranque, y se han ejecutado en un poco de un problema. antes, cuando yo estaba usando la Primavera de datos con hibernate y JPA, podría crear un hibernate.cfg.xml archivo que dar un montón de configuración que puede ser transmitida a un objeto de configuración y, a continuación, en última instancia, crear un objeto SessionFactory que crear un objeto de Sesión que podría ser usado para pasar la consulta a hibernar:

package util;

import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder; 
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();
    private static SessionFactory buildSessionFactory() { 
        try {
        //Create the SessionFactory from hibernate.cfg.xml
        Configuration configuration = new Configuration().configure("hibernate.cfg.xml"); return configuration.buildSessionFactory( new
        StandardServiceRegistryBuilder().applySettings( configuration.getProperties() ).build() ); 
        }
        catch (Throwable ex) {
        //Make sure you log the exception, as it might be swallowed System.err.println("Initial SessionFactory creation failed." + ex); throw new ExceptionInInitializerError(ex);
        } 
    }
    public static SessionFactory getSessionFactory() { return sessionFactory; }
}

hibernate.cfg.xml

<?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">com.mysql.jdbc.Driver</property> 
        <property name="connection.url">jdbc:mysql://localhost:3306/hello-world</property> 
        <property name="connection.username">root</property>
        <property name="connection.password">password</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property> 

        <!-- Create/update tables automatically using mapping metadata -->
        <property name="hbm2ddl.auto">update</property> 

        <!-- Use Annotation-based mapping metadata -->
        <mapping class="entity.Author"/> 
        <mapping class="entity.Article"/> 
    </session-factory>
</hibernate-configuration>

Main.java

    public class HelloWorldClient {

    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().openSession(); 
        Transaction txn = session.getTransaction();

        EntityManagerFactory emf = Persiscance.createEntityManagerFactory("hibernate.cfg.xml");
        EntityManager em = emf.createEntityManager();
        EntityTransaction txn = em.getTransaction();

        try {
            txn.begin();
            Author author = new Author("name", listOfArticlesWritten);
            Article article = new Article("Article Title", author);
            session.save(author);
            session.save(article);

            Query query = session.createQuery("select distinct a.authorName from Article s
                                                where s.author like "Joe%" and title = 'Spring boot');

            List<Article> articles = query.list();

            txn.commit();
        } catch(Exception e) {
            if(txn != null) { txn.rollback(); }
            e.printStackTrace();
        } finally {
            if(session != null) { session.close(); } }
    } 
}

Aquí es donde el problema aparece. No sé cómo evitar la creación de un hibernate.cfg.xml archivo o una sesión de fábrica para consultas personalizadas. en la Primavera de guías de la página, y algunos tutoriales que he trabajado a través de, ellos toman sus DAO y extender la CrudRepository interfaz que le da un montón de métodos, así como un modo de nombrar el método para que Hibernate puede generar el sql por su propia cuenta.

lo que estoy tratando de lograr, al menos en este post es el de ser capaz de ejecutar la consulta anterior en la primavera de arranque. Puedo crear un archivo de propiedades

aplicación.propiedades

# ===============================
# = DATA SOURCE
# ===============================

# Set here configurations for the database connection
spring.datasource.url = jdbc:mysql://localhost:3306/spring-boot-demo
spring.datasource.username = test
spring.datasource.password = test

# Mysql connector
spring.datasource.driverClassName = com.mysql.jdbc.Driver



# ===============================
# = JPA /HIBERNATE
# ===============================

# Specify the DBMS
spring.jpa.database = MYSQL

# Show or not log for each sql query
spring.jpa.show-sql = true

# Ddl auto must be set to "create" to ensure that Hibernate will run the
# import.sql file at application startup

#create-drop| update | validate | none
spring.jpa.hibernate.ddl-auto = update

# SQL dialect for generating optimized queries
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

# ===============================
# = THYMELEAF
# ===============================

spring.thymeleaf.cache = false
#debug=true

Me puedo mover todo, pero la asignación a un archivo de propiedades, pero yo estoy claro de cómo escribir la consulta porque ya no es un objeto de sesión.

2 Comentarios

  1. 13

    Si utiliza la Primavera de Arranque + Spring Data JPA, a continuación, debe configurar el origen de datos (que ahora se ponga en hibernate.cfg.xml) en el application.properties, mediante el uso de la primavera.origen de datos.* propiedades.

    Esto debe crear automáticamente un gerente de la entidad para usted. Si necesita utilizar consultas, puede utilizar Spring Data JPA los repositorios, por ejemplo:

    public interface ArticleRepository extends JpaRepository<Article, Long> {
        @Query("select s from Article s where s.author like ?1 and s.title = ?2")
        List<Article> findByAuthorAndTitle(String author, String title);
    }

    Ahora usted puede autowire el repositorio y el uso de la consulta dada, como este:

    List<Article> articles = repository.findByAuthorAndTitle("Joe%", "Spring boot");

    Si usted realmente necesita consultas personalizadas, usted puede utilizar el Predicado/Criterios de la API de JPA. La primavera ofrece una envuelto versión de estos predicados, llamado Especificaciones.

    De hacer eso, usted extender su ArticleRepository con otra interfaz denominada JpaSpecificationExecutor<Article>. Esto añade algunos extras métodos para su repositorio:

    Specification<Article> spec = Specifications.<Article>where((root, query, cb) -> {
        return cb.and(
             cb.like(root.get("author"), "Joe%"),
             cb.equal(root.get("title"), "Spring boot"));
    });
    List<Article> articles = repository.findAll(spec);

    Esto permite crear de forma dinámica las consultas, a pesar de que su pregunta no es como que realmente lo necesitan.

  2. 2

    En la primavera de aplicación de arranque que no hay necesidad de crear xml de configuración, debe congigure archivo java en sí.
    Comprobar con este ejemplo,

    HTML:

    import java.util.Properties;
    
    import javax.sql.DataSource;
    
    import org.hibernate.annotations.common.util.impl.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.jdbc.datasource.DriverManagerDataSource;
    import org.springframework.orm.hibernate4.HibernateTransactionManager;
    import org.springframework.orm.hibernate4.LocalSessionFactoryBean;
    
    @Configuration
    public class DatabaseConfig {
    
     private org.jboss.logging.Logger log = LoggerFactory.logger(DatabaseConfig.class);
    
     @Value("${db.driver}")
     private String DB_DRIVER;
    
     @Value("${db.username}")
     private String DB_USERNAME;
    
     @Value("${db.password}")
     private String DB_PASSWORD;
    
     @Value("${db.url}")
     private String DB_URL;
    
     @Value("${hibernate.dialect}")
     private String HIBERNATE_DIALECT;
    
     @Value("${hibernate.show_sql}")
     private String HIBERNATE_SHOW_SQL;
    
     @Value("${hibernate.hbm2ddl.auto}")
     private String HIBERNATE_HBM2DDL_AUTO;
    
     @Value("${entitymanager.packagesToScan}")
     private String ENTITYMANAGER_PACKAGES_TO_SCAN;
    
     @Bean
     public DataSource dataSource() {
      DriverManagerDataSource dataSource = null;
      try {
       dataSource = new DriverManagerDataSource();
       dataSource.setDriverClassName(DB_DRIVER);
       dataSource.setUrl(DB_URL);
       dataSource.setUsername(DB_USERNAME);
       dataSource.setPassword(DB_PASSWORD);
      } catch (Exception e) {
       e.getMessage();
      }
      return dataSource;
     }
    
     @Bean
     public LocalSessionFactoryBean sessionFactory() {
      LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean();
      sessionFactoryBean.setDataSource(dataSource());
      sessionFactoryBean.setPackagesToScan(ENTITYMANAGER_PACKAGES_TO_SCAN);
      Properties hibernateProps = new Properties();
      hibernateProps.put("hibernate.dialect", HIBERNATE_DIALECT);
      hibernateProps.put("hibernate.show_sql", HIBERNATE_SHOW_SQL);
      hibernateProps.put("hibernate.hbm2ddl.auto", HIBERNATE_HBM2DDL_AUTO);
      sessionFactoryBean.setHibernateProperties(hibernateProps);
      return sessionFactoryBean;
     }
    
     @Bean
     public HibernateTransactionManager transactionManager() {
      HibernateTransactionManager transactionManager = new HibernateTransactionManager();
      transactionManager.setSessionFactory(sessionFactory().getObject());
      return transactionManager;
     }
    }

Dejar respuesta

Please enter your comment!
Please enter your name here