javaconfig에서 Spring 3.2 + 최대 절전 모드 4를 올바르게 사용하는 방법

StackOverflow https://stackoverflow.com//questions/20039333

문제

Spring 3.2 + Hibernate 4 + javaconfig에서 테스트하고 싶습니다.

build.gradle의 내용은 다음과 같습니다.

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'org.gradle.api.plugins:gradle-tomcat-plugin:0.9.9'
    }
}

apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'war'
apply plugin: 'tomcat'

ext.springVersion =       '3.2.4.RELEASE'
ext.springMobileVersion = '1.1.0.RELEASE'
ext.thymeleafVersion =    '2.0.19'
ext.aspectJVersion =      '1.6.9'
ext.cglibVersion =        '2.2'
ext.slf4jVersion =        '1.6.1'
ext.servletJstlVersion =  '1.2'
ext.servletApiVersion =   '3.0.1'
ext.servletJspVersion =   '2.1'
ext.junitVersion =        '4.11'
ext.tomcatVersion =       '7.0.42'
ext.pgsqlVersion =        '9.1-901.jdbc4'
ext.mockiteoCoreVersion = '1.9.5'
ext.mailVersion         = '1.4.7'
ext.dataBindVersion     = '2.2.3'
ext.hbVersion           = '4.2.7.Final'
ext.guavaVersion        = '15.0'
ext.javassistVersion    = '3.18.0-GA'

war {
    webInf {
        include "src/main/webapp/resources/**"
    }
}

dependencies {
    compile("org.springframework:spring-context:$springVersion") {
        exclude module: 'commons-logging'
    }
    compile "org.springframework:spring-context-support:$springVersion"
    compile "org.springframework:spring-web:$springVersion"
    compile "org.springframework:spring-webmvc:$springVersion"
    compile "org.springframework.mobile:spring-mobile-device:$springMobileVersion"
    compile "org.springframework:spring-tx:$springVersion"
    compile "org.springframework:spring-orm:$springVersion"

    compile "com.fasterxml.jackson.core:jackson-databind:$dataBindVersion"
    compile "javax.mail:mail:$mailVersion"
    compile "org.thymeleaf:thymeleaf-spring3:$thymeleafVersion"
    compile "org.aspectj:aspectjrt:$aspectJVersion"
    compile "cglib:cglib-nodep:$cglibVersion"
    compile "javax.inject:javax.inject:1"
    compile "org.slf4j:slf4j-api:$slf4jVersion"
    compile "org.slf4j:jcl-over-slf4j:$slf4jVersion"
    compile "org.slf4j:slf4j-log4j12:$slf4jVersion"
    compile "javax.servlet:jstl:$servletJstlVersion"
    providedCompile("javax.servlet:javax.servlet-api:$servletApiVersion")
    providedCompile("javax.servlet.jsp:jsp-api:$servletJspVersion")

    // Persistence
    compile "postgresql:postgresql:$pgsqlVersion"
    compile "org.hibernate:hibernate-core:$hbVersion"
    compile "org.hibernate:hibernate-entitymanager:$hbVersion"
    compile "org.apache.tomcat:tomcat-dbcp:$tomcatVersion"
    compile "org.javassist:javassist:$javassistVersion"

    // Tools
    compile "com.google.guava:guava:$guavaVersion"

    // TEST
    testCompile "junit:junit:$junitVersion"
    testCompile "org.mockito:mockito-core:$mockiteoCoreVersion"
    testCompile "org.springframework:spring-test:$springVersion"
    testCompile "org.hamcrest:hamcrest-core:1.3"
    testCompile "org.hamcrest:hamcrest-library:1.3"
    testCompile "org.apache.commons:commons-lang3:3.1"

    // TOMCAT
    tomcat("org.apache.tomcat.embed:tomcat-embed-core:$tomcatVersion",
            "org.apache.tomcat.embed:tomcat-embed-logging-juli:$tomcatVersion")
    tomcat("org.apache.tomcat.embed:tomcat-embed-jasper:$tomcatVersion") {
        exclude group: 'org.eclipse.jdt.core.compiler', module: 'ecj'
    }
}

repositories {
    mavenCentral()
    maven { url 'http://repo.spring.io/libs-release' }
}

task wrapper(type: Wrapper) {
    gradleVersion = '1.8'
}

PersistenceConfig 콘텐츠는 다음입니다.

@Configuration
@EnableTransactionManagement
@PropertySource({ "classpath:pgsql.properties" })
@ComponentScan(basePackages = {"com.example.persistence"})
public class PersistenceConfig
{
    @Autowired
    private Environment env;

    @Bean
    public DataSource dataSource()
    {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName(env.getProperty("jdbc.driverClassName"));
        dataSource.setUrl(env.getProperty("jdbc.url"));
        dataSource.setUsername(env.getProperty("jdbc.user"));
        dataSource.setPassword(env.getProperty("jdbc.pass"));
        return dataSource;
    }

    @Bean
    public LocalSessionFactoryBean sessionFactory()
    {
        LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
        sessionFactory.setDataSource(dataSource());
        sessionFactory.setPackagesToScan(new String[] { "com.example.persistence.domain" });
        sessionFactory.setHibernateProperties(hibernateProperties());
        return sessionFactory;
    }

    @Bean
    public HibernateTransactionManager transactionManager()
    {
        HibernateTransactionManager txManager = new HibernateTransactionManager();
        txManager.setSessionFactory(sessionFactory().getObject());
        return txManager;
    }

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

    Properties hibernateProperties() {
        return new Properties() {
            {
                setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
                setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
                setProperty("hibernate.globally_quoted_identifiers", "true");
            }
        };
    }
}

ProductServiceTest 콘텐츠는 다음입니다.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {PersistenceConfig.class})
public class ProductServiceTest
{
    private static final Logger LOG = LoggerFactory.getLogger(ProductServiceTest.class);

    @Autowired
    private ProductService productService;

    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public final void listApplicationBeans() throws Exception
    {
        List<String> beans = Arrays.asList(applicationContext.getBeanDefinitionNames());
        for (String bean: beans)
        {
            LOG.info(String.format("--> App Beans [%s]", bean));
        }
    }
}

persistence.properties 콘텐츠는 다음과 같습니다.

# jdbc
jdbc.driverClassName=org.postgresql.Driver
jdbc.url=jdbc:postgresql://some_address:5432/some_database
jdbc.user=someuser
jdbc.pass=somepassword

# hibernate
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
hibernate.show_sql=true
hibernate.hbm2ddl.auto=create-drop

제품 내용은 다음과 같습니다.

@Entity
public class Product implements Serializable
{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    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;
    }

    public Product(String name)
    {
        setName(name);
    }

    @Override
    public String toString()
    {
        StringBuilder builder = new StringBuilder();

        builder.append(Product.class.getSimpleName()).append(" [\n");
        builder.append("id = ").append(id).append("\n");
        builder.append("name = ").append(name).append("\n");
        builder.append("]");

        return builder.toString();
    }

}

ProductDao 콘텐츠는 다음과 같습니다.

import org.springframework.stereotype.Repository;
import com.example.persistence.dao.common.AbstractDao;
import com.example.persistence.domain.Product;
@Repository
public class ProductDao extends AbstractDao<Product>
{
    public ProductDao()
    {
        super();
        setClazz(Product.class);
    }
}

ProductService 콘텐츠는 다음과 같습니다.

@Service
public class ProductService extends AbstractService<Product>
{
    @Autowired
    private ProductDao dao;

    public ProductService()
    {
        super();
    }

    @Override
    protected IOperation<Product> getDao()
    {
        return dao;
    }
}

에 의한 결과 Gradle 클린 테스트:

java.lang.IllegalStateException: Failed to load ApplicationContext
    at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:99)
    at org.springframework.test.context.TestContext.getApplicationContext(TestContext.java:122)
    at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary(ServletTestExecutionListener.java:105)
    at org.springframework.test.context.web.ServletTestExecutionListener.prepareTestInstance(ServletTestExecutionListener.java:74)
    at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:312)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:211)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:288)
    at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:284)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:88)
    at org.junit.runners.ParentRunner$3.run(ParentRunner.java:238)
    at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:63)
    at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:236)
    at org.junit.runners.ParentRunner.access$000(ParentRunner.java:53)
    at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:229)
    at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
    at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71)
    at org.junit.runners.ParentRunner.run(ParentRunner.java:309)
    at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174)
    at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecuter.runTestClass(JUnitTestClassExecuter.java:80)
    at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassExecuter.execute(JUnitTestClassExecuter.java:47)
    at org.gradle.api.internal.tasks.testing.junit.JUnitTestClassProcessor.processTestClass(JUnitTestClassProcessor.java:69)
    at org.gradle.api.internal.tasks.testing.SuiteTestClassProcessor.processTestClass(SuiteTestClassProcessor.java:49)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at org.gradle.messaging.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)
    at org.gradle.messaging.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
    at org.gradle.messaging.dispatch.ContextClassLoaderDispatch.dispatch(ContextClassLoaderDispatch.java:32)
    at org.gradle.messaging.dispatch.ProxyDispatchAdapter$DispatchingInvocationHandler.invoke(ProxyDispatchAdapter.java:93)
    at com.sun.proxy.$Proxy2.processTestClass(Unknown Source)
    at org.gradle.api.internal.tasks.testing.worker.TestWorker.processTestClass(TestWorker.java:103)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:606)
    at org.gradle.messaging.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:35)
    at org.gradle.messaging.dispatch.ReflectionDispatch.dispatch(ReflectionDispatch.java:24)
    at org.gradle.messaging.remote.internal.hub.MessageHub$Handler.run(MessageHub.java:355)
    at org.gradle.internal.concurrent.DefaultExecutorFactory$StoppableExecutorImpl$1.run(DefaultExecutorFactory.java:66)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:724)
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'productService': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.example.persistence.dao.impl.ProductDao com.example.persistence.service.impl.ProductService.dao; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [com.example.persistence.dao.impl.ProductDao] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:288)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1116)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:519)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:458)
    at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:295)
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:223)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:292)
    at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:194)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:628)
    at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:932)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:479)
    at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:120)
    at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:60)
    at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.delegateLoading(AbstractDelegatingSmartContextLoader.java:100)
    at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.loadContext(AbstractDelegatingSmartContextLoader.java:248)
    at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContextInternal(CacheAwareContextLoaderDelegate.java:64)
    at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:91)
    ... 44 more
Caused by: org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.example.persistence.dao.impl.ProductDao com.example.persistence.service.impl.ProductService.dao; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [com.example.persistence.dao.impl.ProductDao] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:514)
    at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:87)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:285)
    ... 60 more
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [com.example.persistence.dao.impl.ProductDao] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)}
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:988)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:858)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:770)
    at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:486)
    ... 62 more
도움이 되었습니까?

해결책

내 테스트 스위트의 Spring Hibernate 프로젝트에서 비슷한 문제를 발견했습니다.

내가 문제를 해결할 수 있는 유일한 방법은 슈퍼 클래스를 유형으로 사용하여 클래스를 자동 연결하는 것이었습니다(AbstractService 귀하의 경우) 그런 다음 @Qualifier 내가 언급하고 있는 자식 클래스를 Spring에게 알려주기 위해.귀하의 경우에는 다음과 같습니다.

@Qualifier("ProductService")
@Autowired
private AbstractService productService;

캐스팅해야 하는 테스트 함수에서는 그때처럼 고통스럽습니다. productService 반대하다 ProductService 하위 클래스에 속한 메소드를 사용할 때마다.따라서 이미 다른 솔루션을 사용하여 이 문제를 해결했다면 공유해 주세요.

다른 팁

스택 트레이스에 따르면 : 

Could not autowire field: private com.example.persistence.dao.impl.ProductDao
com.example.persistence.service.impl.ProductService.dao; nested exception is 
org.springframework.beans.factory.NoSuchBeanDefinitionException:
.

이 문제를 발견하면 다음을 제거합니다.

  1. bean은 주석이 지정되지 않았거나 구성 요소 스캔에 의해 적용되지 않습니다. 당신은 정의했습니다 @Componentscan (기본= { "com.example.persistence"})

    그것은 당신의 패키지 com.example.persistence.dao.impl.ProductDao를 다룹니다 여기에서 괜찮아요.
  2. 주석이 올바른지 확인하십시오 : ProductDao는 @repository를 주석으로

    은 괜찮아 보입니다.
  3. com.example.persistence.dao.impl.ProductDao가 클래스 경로에 있는지 확인하십시오. 졸업식 테스트 명령을 실행하고 있습니다. 즉, 테스트 실행 전에 코드가 컴파일됩니다 (테스트가 컴파일 작업에 따라 다릅니다).
    컴파일하면 ProductDAO가 ClassPath
    4. 라고 생각합니다.
  4. JUNIT가 부트 스트랩을위한 필수 구성이 있는지 확인하십시오. 봄 응용 프로그램 컨텍스트.

    @ContextConfiguration
    클래스는 구성 클래스를 가리 킵니다. Spring이 기본 DelegatingSmartContextLoader (구성 및 버전> 3.2에서 @WebAppConfiguration no @webappconfiguration)를 사용하므로 로더 속성이 정의되지 않았습니다. 은 나에게 좋게 보입니다.

    5. 불행히도 나는 어떤 문제도 찾을 수 없으며 모든 것이 잘 보이는 것처럼 보입니다 (이 체크 목록은 누군가를 도울 수 있기를 바랍니다).
    그래서 나는 그 문제가 누락 된 세부 사항의 어딘가에 있다고 추측 할 것입니다. 다른 패키지에서 ProductDao 클래스를 사용하고 제품 서비스 또는 잘못된 인터페이스 등의 잘못된 것을 사용하고 있습니다.

    희망이 도움이

i Hibernate Java 구성의 예와 공유합니다. 나는 당신이 그것을 사랑하기를 바랍니다 :

사전 요구 사항 : pom.xml 

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>4.0.6.RELEASE</spring.version>
    </properties>

    <dependencies>

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

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

        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>

        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>4.1.9.Final</version>
        </dependency>

        <!-- POSTGRESQL -->
        <dependency>
            <groupId>postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>9.1-901-1.jdbc4</version>
        </dependency>

    </dependencies>
.

1 단계 : application.properties 

################### DataSource Configuration ##########################
jdbc.driverClassName=org.postgresql.Driver
jdbc.url=jdbc:postgresql://localhost/curso_db
jdbc.username=alumno
jdbc.password=alumno

#################### Hibernate Configuration ##########################
hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
hibernate.show_sql=true

packagesToScan=com.curso.online.model
.

2 단계 : config.java 

package com.curso.online;

import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
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.context.annotation.PropertySources;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.orm.hibernate4.HibernateTransactionManager;
import org.springframework.orm.hibernate4.LocalSessionFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@PropertySources(value = { @PropertySource("classpath:/application.properties") })
@ComponentScan(basePackages = "com.curso.online")
public class Config {

    @Value("${jdbc.driverClassName}")
    private String KEY_DRIVER_CLASS;

    @Value("${jdbc.url}")
    private String KEY_JDBC_URL;

    @Value("${jdbc.username}")
    private String KEY_JDBC_USERNAME;

    @Value("${jdbc.password}")
    private String KEY_JDBC_PASSWORD;

    @Value("${hibernate.dialect}")
    private String KEY_HIBERNATE_DIALECT;

    @Value("${hibernate.show_sql}")
    private String KEY_HBERNATE_SHOW_SQL;

    @Value("${packagesToScan}")
    private String KEY_ENTITIES_PKG;

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

    @Bean
    public LocalSessionFactoryBean sessionFactory() {
        LocalSessionFactoryBean factory = new LocalSessionFactoryBean();
        factory.setDataSource(dataSource());
        factory.setPackagesToScan(KEY_ENTITIES_PKG);
        factory.setHibernateProperties(hibernateProperties());
        return factory;
    }

    public Properties hibernateProperties() {
        Properties properties = new Properties();
        properties.setProperty("hibernate.dialect", KEY_HIBERNATE_DIALECT);
        properties.setProperty("hibernate.show_sql", KEY_HBERNATE_SHOW_SQL);
        return properties;
    }

    @Bean
    @Autowired
    public HibernateTransactionManager transactionManager(
            SessionFactory sessionFactory) {
        return new HibernateTransactionManager(sessionFactory);
    }

    @Bean
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName(KEY_DRIVER_CLASS);
        dataSource.setUrl(KEY_JDBC_URL);
        dataSource.setUsername(KEY_JDBC_USERNAME);
        dataSource.setPassword(KEY_JDBC_PASSWORD);
        return dataSource;
    }

}
.

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top