spring-test-dbunit can't find #Test annotation - spring

I've set up spring-test-dbunit but I get following exception:
testSometing(com.my.package.dbunit.DbUnit) Time elapsed: 13.013 s <<<
ERROR! java.lang.NoSuchMethodError:
org.springframework.core.annotation.AnnotationUtils.findAnnotation(Ljava/lang/reflect/AnnotatedElement;Ljava/lang/Class;)Ljava/lang/annotation/Annotation;
The test class looks like following:
package com.my.package.dbunit;
import com.github.springtestdbunit.DbUnitTestExecutionListener;
import com.github.springtestdbunit.annotation.DatabaseSetup;
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.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
#RunWith(SpringJUnit4ClassRunner.class)
#ContextConfiguration("/test-application.xml")
#TestExecutionListeners({DependencyInjectionTestExecutionListener.class, DbUnitTestExecutionListener.class, DbUnitTestExecutionListener.class})
public class DbUnit {
#Autowired
public MyDAO myDAO;
#Test
#DatabaseSetup("target/partial.xml")
public void testSometing() throws Exception {
int rootId = 123;
MyClass root = myDAO.getById(rootId);
}
}
The test-application.xml looks like following:
...
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
...
pom.xml looks like this
...
<dependency>
<groupId>org.dbunit</groupId>
<artifactId>dbunit</artifactId>
<version>2.5.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.github.springtestdbunit</groupId>
<artifactId>spring-test-dbunit</artifactId>
<version>1.3.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
...
It seems like that the error exists because the #Test annotation can't be resolved. I don't know why

Your version of spring-test-dbunit is most probably incompatible with your spring-version. spring-test-dbunit in version 1.3.0 (which seems to be the most recent one) depends on Spring 4.2.5. You are probably using a more recent Spring version in your project which does not have a findAnnotation method in AnnotationUtils any more.
You basically have two things that you can do right now:
Use Spring 4 (which might be problematic in the future, when support is dropped)
Find an alternative to spring-test-dbunit

Related

Distributed transaction using spring and spring jdbctemplate

I have two datasource with two schema in oracle, I am performing unittest but it is failing. I want if the second transaction failed then it should rollback the first trasaction. Below is my code.
package com.test.db;
import static org.junit.Assert.assertEquals;
import java.util.Date;
import javax.sql.DataSource;
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.DataIntegrityViolationException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.AfterTransaction;
import org.springframework.test.context.transaction.BeforeTransaction;
import org.springframework.transaction.annotation.Transactional;
//#EnableTransactionManagement
#RunWith(SpringJUnit4ClassRunner.class)
#ContextConfiguration(locations="/META-INF/spring/data-source-context.xml")
public class MultipleDatasourceTests {
private JdbcTemplate jdbcTemplate;
private JdbcTemplate otherJdbcTemplate;
#Autowired
public void setDataSources(#Qualifier("dataSource") DataSource dataSource,
#Qualifier("otherDataSource") DataSource otherDataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
this.otherJdbcTemplate = new JdbcTemplate(otherDataSource);
}
#BeforeTransaction
public void clearData() {
jdbcTemplate.update("delete from T_ORACLE1");
otherJdbcTemplate.update("delete from T_ORACLE1");
}
#AfterTransaction
public void checkPostConditions() {
int count = jdbcTemplate.queryForInt("select count(*) from T_ORACLE1");
// This change was rolled back by the test framework
assertEquals(0, count);
count = otherJdbcTemplate.queryForInt("select count(*) from T_ORACLE1");
// This rolls back as well if the connections are managed together
assertEquals(0, count);
}
/**
* Vanilla test case for two inserts into two data sources. Both should roll
* back.
*
* #throws Exception
*/
#Transactional
#Test
public void testInsertIntoTwoDataSources() throws Exception {
jdbcTemplate.update("delete from T_ORACLE1");
otherJdbcTemplate.update("delete from T_ORACLE2");
int count = jdbcTemplate.update(
"INSERT into T_ORACLE1 (id,name,foo_date) values (?,?,null)", 0,
"foo");
assertEquals(1, count);
count = otherJdbcTemplate
.update(
"INSERT into T_ORACLE2 (id,operation,name,audit_date) values (?,?,?,?)",
1, "INSERT", "foo", new Date());
assertEquals(1, count);
}
/**
* Shows how to check the operation on the inner data source to see if it
* has already been committed, and if it has do something different, instead
* of just hitting a {#link DataIntegrityViolationException}.
*
* #throws Exception
*/
#Transactional
#Test
public void testInsertWithCheckForDuplicates() throws Exception {
int count = jdbcTemplate.update(
"INSERT into T_ORACLE1 (id,name,foo_date) values (?,?,null)", 0,
"foo");
assertEquals(1, count);
count = otherJdbcTemplate.update(
"UPDATE T_ORACLE2 set operation=?, name=?, audit_date=? where id=?",
"UPDATE", "foo", new Date(), 0);
if (count == 0) {
count = otherJdbcTemplate.update(
"INSERT into T_ORACLE2 (id,operation,name,audit_date) values (?,?,?,?)",
0, "INSERT", "foo", new Date());
}
assertEquals(1, count);
}
}
XML
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:tx="http://www.springframework.org/schema/tx" 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-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config />
<context:component-scan base-package="com.test.*"/>
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<property name="url" value="jdbc:oracle:thin:#//localhost:1521/TESTDB1" />
<property name="username" value="ORACLE1"/>
<property name="password" value="ORACLE1"/>
</bean>
<bean id="otherDataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<property name="url" value="jdbc:oracle:thin:#//localhost:1521/TESTDB2" />
<property name="username" value="ORACLE2"/>
<property name="password" value="ORACLE2"/>
</bean>
<bean id="transactionManager" class="com.test.db.MultiTransactionManager">
<property name="transactionManagers">
<list>
<bean
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<bean
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="otherDataSource" />
</bean>
</list>
</property>
</bean>
</beans>
package com.test.db;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionException;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.AbstractPlatformTransactionManager;
import org.springframework.transaction.support.DefaultTransactionStatus;
public class MultiTransactionManager extends
AbstractPlatformTransactionManager {
private List<PlatformTransactionManager> transactionManagers = new ArrayList<PlatformTransactionManager>();
private ArrayList<PlatformTransactionManager> reversed;
public void setTransactionManagers(
List<PlatformTransactionManager> transactionManagers) {
this.transactionManagers = transactionManagers;
reversed = new ArrayList<PlatformTransactionManager>(
transactionManagers);
Collections.reverse(reversed);
}
#Override
protected void doBegin(Object transaction, TransactionDefinition definition)
throws TransactionException {
#SuppressWarnings("unchecked")
List<DefaultTransactionStatus> list = (List<DefaultTransactionStatus>) transaction;
for (PlatformTransactionManager transactionManager : transactionManagers) {
DefaultTransactionStatus element = (DefaultTransactionStatus) transactionManager
.getTransaction(definition);
list.add(0, element);
}
}
#Override
protected void doCommit(DefaultTransactionStatus status)
throws TransactionException {
#SuppressWarnings("unchecked")
List<DefaultTransactionStatus> list = (List<DefaultTransactionStatus>) status
.getTransaction();
int i = 0;
for (PlatformTransactionManager transactionManager : reversed) {
TransactionStatus local = list.get(i++);
try {
transactionManager.commit(local);
} catch (TransactionException e) {
logger.error("Error in commit", e);
// Rollback will ensue as long as rollbackOnCommitFailure=true
throw e;
}
}
}
#Override
protected Object doGetTransaction() throws TransactionException {
return new ArrayList<DefaultTransactionStatus>();
}
#Override
protected void doRollback(DefaultTransactionStatus status)
throws TransactionException {
#SuppressWarnings("unchecked")
List<DefaultTransactionStatus> list = (List<DefaultTransactionStatus>) status
.getTransaction();
int i = 0;
TransactionException lastException = null;
for (PlatformTransactionManager transactionManager : reversed) {
TransactionStatus local = list.get(i++);
try {
transactionManager.rollback(local);
} catch (TransactionException e) {
// Log exception and try to complete rollback
lastException = e;
logger.error("Error in rollback", e);
}
}
if (lastException!=null) {
throw lastException;
}
}
}
My pom.xml
<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.springsource.open</groupId>
<artifactId>spring-best-db-db</artifactId>
<version>2.0.0.CI-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Spring Best Efforts DB-DB</name>
<description><![CDATA[Sample project showing multi DataSource transaction
processing with Spring using best efforts 1PC.
]]> </description>
<properties>
<maven.test.failure.ignore>true</maven.test.failure.ignore>
<spring.framework.version>4.1.4.RELEASE</spring.framework.version>
</properties>
<profiles>
<profile>
<id>strict</id>
<properties>
<maven.test.failure.ignore>false</maven.test.failure.ignore>
</properties>
</profile>
<profile>
<id>fast</id>
<properties>
<maven.test.skip>true</maven.test.skip>
</properties>
</profile>
</profiles>
<dependencies>
<dependency>
<groupId>hsqldb</groupId>
<artifactId>hsqldb</artifactId>
<version>1.8.0.7</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>1.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1</version>
<exclusions>
<exclusion>
<groupId>avalon-framework</groupId>
<artifactId>avalon-framework</artifactId>
</exclusion>
<exclusion>
<groupId>logkit</groupId>
<artifactId>logkit</artifactId>
</exclusion>
<exclusion>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.derby</groupId>
<artifactId>derby</artifactId>
<version>10.2.1.6</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.9</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
<version>2.4</version>
<scope>test</scope>
</dependency>
<!-- Spring Dependencies -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.framework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.framework.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.framework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.framework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.framework.version}</version>
</dependency>
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc8</artifactId>
<version>12.1.0.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.github.marcus-nl.btm/btm-spring -->
<dependency>
<groupId>com.github.marcus-nl.btm</groupId>
<artifactId>btm-spring</artifactId>
<version>3.0.0-mk1</version>
</dependency>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>6.0</version>
</dependency>
</dependencies>
</project>
TABLE IN ORACLE1 database
create table T_ORACLE1 (
id integer not null primary key,
name varchar(80),
foo_date timestamp
);
Table in ORACLE2 database
create table T_ORACLE2 (
id integer not null primary key,
operation varchar(20),
name varchar(80),
audit_date timestamp
);
I googled to use BitronixTransactionManager but, did not get any clue how to configure for two datasource.
It seems we can use hibernate but, I don't want to use hibernate. I want either jdbctemplate with sql query or simple jdbc.
The error I am getting is
java.lang.IllegalStateException: Cannot activate transaction synchronization - already active
at org.springframework.transaction.support.TransactionSynchronizationManager.initSynchronization(TransactionSynchronizationManager.java:270)
I am new to distributed transaction. Could you please help me on this? Is it possible to use two datasource but one transactionmanager?
You have to use XA datasources if you want to achieve distributed transactions and the transaction manager has to support XA transactions as well.
Using the Bitronix transaction manager should do it, but you have to use XA datasource as well: an Oracle-based implementation seems to be available in Oracle's JDBC driver (cf. https://docs.oracle.com/cd/E17904_01/web.1111/e13731/thirdpartytx.htm#WLJTA266).
You can find an example of Spring configuration for Bitronix here: https://www.snip2code.com/Snippet/652599/Example-distributed-XA-transaction-confi/, just make sure to adjust the datasources properties to use oracle.jdbc.xa.client.OracleXADataSource instead of the PostgreSQL one.
Note however that XA/distributed transactions are no silver bullet and won't be able to cope some classes of problem (e.g. network failures); you should really think to possible alternatives before taking that road.

2023 [localhost-startStop-1] INFO org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping not load when running tomcat

How to config for loading this package
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.
When i run Tomcat everything i got only as below:
0 [localhost-startStop-1] INFO org.springframework.web.context.ContextLoader - Root WebApplicationContext: initialization started
65 [localhost-startStop-1] INFO org.springframework.web.context.support.XmlWebApplicationContext - Refreshing Root WebApplicationContext: startup date [Fri Mar 11 21:55:33 EET 2016]; root of context hierarchy
366 [localhost-startStop-1] INFO org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loading XML bean definitions from ServletContext resource [/WEB-INF/applicationContext.xml]
470 [localhost-startStop-1] INFO org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loading XML bean definitions from ServletContext resource [/WEB-INF/spring-data.xml]
836 [localhost-startStop-1] INFO org.springframework.context.support.PropertySourcesPlaceholderConfigurer - Loading properties file from URL [file:/Volumes/Data/JavaEE/workspace/.metadata/.plugins/org.eclipse.wst.server.core/tmp0/wtpwebapps/d14-spring_mvc/WEB-INF/classes/db_connection.properties]
1045 [localhost-startStop-1] INFO org.springframework.web.context.ContextLoader - Root WebApplicationContext: initialization completed in 1042 ms
So i got problem about DispatcherServlet can't find mapping uri with servlet.
1735055 [http-nio-8001-exec-5] WARN org.springframework.web.servlet.PageNotFound - No mapping found for HTTP request with URI [/vietjob/tyopaikka.lista] in DispatcherServlet with name 'vietjob'
pom.xlm
<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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>vjb.de</groupId>
<artifactId>vietjob</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>vietjob Maven Webapp</name>
<url>http://maven.apache.org</url>
<properties>
<spring.version>4.0.0.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-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.5</version>
</dependency>
<dependency>
<groupId>org.jumpmind.symmetric.jdbc</groupId>
<artifactId>mariadb-java-client</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<version>1</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
<version>1.9.5</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
<version>1.1.0.Final</version>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-all</artifactId>
<version>1.3</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.0.3.Final</version>
</dependency>
</dependencies>
<build>
<finalName>vietjob</finalName>
</build>
</project>
servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
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
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- Configures the #Controller programming model -->
<mvc:annotation-driven />
<context:component-scan base-package="vjb.de.vietjob" />
<!-- Resolves view names to protected .jsp resources within the /WEB-INF/views
directory -->
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/" />
<property name="suffix" value=".jsp" />
</bean>
<!-- Forwards requests to the "/" resource to the "welcome" view -->
<mvc:view-controller path="/" view-name="index" />
<!-- location of static content (images, js and css files) -->
<mvc:resources mapping="/resources/**" location="/resources/" />
<bean id="messageSource"
class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
<property name="basename" value="classpath:lang" />
<property name="defaultEncoding" value="UTF-8"/>
</bean>
<bean id="localeResolver"
class="org.springframework.web.servlet.i18n.CookieLocaleResolver">
<property name="defaultLocale" value="en" />
</bean>
<mvc:interceptors>
<bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
<property name="paramName" value="lang" />
</bean>
</mvc:interceptors>
</beans>
Controller
package vjb.de.vietjob.controller;
import java.util.List;
import javax.inject.Inject;
import javax.validation.Valid;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import vjb.de.vietjob.bean.Duuni;
import vjb.de.vietjob.bean.EhdokasImpl;
import vjb.de.vietjob.dao.DuuniDao;
#Controller
#RequestMapping(value = "/")
public class DuuniController {
#Inject
private DuuniDao duunidao;
public DuuniDao getDuuniDao() {
return this.duunidao;
}
public void setDuuniDao(DuuniDao duunidao) {
this.duunidao = duunidao;
}
// Metodi näyttä kaikki työpaikat, jotka ovat oleva tietokannasta
#RequestMapping(value = "/tyopaikka.lista", method = RequestMethod.GET)
public String showDuuni(Model model) {
List<Duuni> duunit = duunidao.showDuuni();
model.addAttribute("duunit", duunit);
return "duuni/tyopaikka";
}
// Metodi kotisivulle
#RequestMapping(value = "/", method = RequestMethod.GET)
public String returnIndex() {
return "index";
}
// Metodi näyttää lisätietoja työpaikasta
#RequestMapping(value = "/tyopaikka.lista/{id}", method = RequestMethod.GET)
public String showYksiDuuni(
#RequestParam(value = "id", required = false) Integer id,
Model model) {
Duuni duuni = duunidao.showYksiDuuni(id);
model.addAttribute("duuni", duuni);
return "duuni/yksipaikka";
}
// Metodi luo uusi ehdokkaan lomake
#RequestMapping(value = "lomake.luo", method = RequestMethod.POST)
public String getUusiEhdokas(
#ModelAttribute(value = "ehdokas") #Valid EhdokasImpl ehdokas,
BindingResult result) {
return "lomake/ehdokas_lomake";
}
}
Controller modify
package vjb.de.vietjob.controller;
import java.util.List;
import javax.inject.Inject;
import javax.validation.Valid;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import vjb.de.vietjob.bean.Duuni;
import vjb.de.vietjob.bean.EhdokasImpl;
import vjb.de.vietjob.dao.DuuniDao;
#Controller
/*#RequestMapping(value = "/")*/
public class DuuniController {
#Inject
private DuuniDao duunidao;
public DuuniDao getDuuniDao() {
return this.duunidao;
}
public void setDuuniDao(DuuniDao duunidao) {
this.duunidao = duunidao;
}
// Metodi näyttä kaikki työpaikat, jotka ovat oleva tietokannasta
#RequestMapping(value = "tyopaikka.lista", method = RequestMethod.GET)
public String showDuuni(Model model) {
List<Duuni> duunit = duunidao.showDuuni();
model.addAttribute("duunit", duunit);
return "duuni/tyopaikka";
}
#RequestMapping(value = "/tyopaikka.lista", method = RequestMethod.GET)
public String showDuuni1(Model model) {
List<Duuni> duunit = duunidao.showDuuni();
model.addAttribute("duunit", duunit);
return "duuni/tyopaikka";
}
#RequestMapping(value = "vietjob/tyopaikka.lista", method = RequestMethod.GET)
public String showDuuni2(Model model) {
List<Duuni> duunit = duunidao.showDuuni();
model.addAttribute("duunit", duunit);
return "duuni/tyopaikka";
}
#RequestMapping(value = "/vietjob/tyopaikka.lista", method = RequestMethod.GET)
public String showDuuni3(Model model) {
List<Duuni> duunit = duunidao.showDuuni();
model.addAttribute("duunit", duunit);
return "duuni/tyopaikka";
}
// Metodi kotisivulle
#RequestMapping(value = "/", method = RequestMethod.GET)
public String returnIndex() {
return "index";
}
}
Your controller class has a top level #RequestMapping("/"), try changing that to #RequestMapping("/vietjob").

Error creating bean 'org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#1'

I'm trying to create a web-app, using Maven and Intellij Idea. Tests work fine as installing in .war-file. But when I try to refer to my rest with jetty, I have lots of error cases:
Error creating bean with name 'org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#1' defined in ServletContext resource [/WEB-INF/rest-spring.xml]: Initialization of bean failed;
nested exception is java.lang.NoClassDefFoundError: com/fasterxml/jackson/core/JsonProcessingException
Here are rest module files:
Web.xml
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<servlet>
<servlet-name>restDispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--the location of the spring context configuration file-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/rest-spring.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>restDispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
rest-spring.xml
<?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:jdbc="http://www.springframework.org/schema/jdbc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<mvc:annotation-driven/>
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:model.properties</value>
<value>classpath:database.properties</value>
<value>classpath:automobile.properties</value>
</list>
</property>
</bean>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<jdbc:initialize-database data-source="dataSource">
<jdbc:script location="classpath*:create-tables-model.sql"/>
<jdbc:script location="classpath*:create-tables-automobile.sql"/>
<jdbc:script location="classpath*:data-script.sql"/>
</jdbc:initialize-database>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<ref bean="jsonConverter"/>
</list>
</property>
</bean>
<bean id="jsonConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
<property name="supportedMediaTypes" value="application/json" />
<property name="prettyPrint" value="true" />
</bean>
<bean id="modelDao" class="com.dao.ModelDaoImpl">
<constructor-arg ref="dataSource" />
</bean>
<bean id="automobileDao" class="com.dao.AutomobileDaoImpl">
<constructor-arg ref="dataSource" />
</bean>
<bean id="modelService" class="com.service.ModelServiceImpl">
<property name = "modelDao" ref = "modelDao"/>
</bean>
<bean id="automobileService" class="com.service.AutomobileServiceImpl">
<property name = "automobileDao" ref = "automobileDao"/>
</bean>
<context:component-scan base-package="com.rest"/>
</beans>
ModelRestController
package com.rest;
import com.dto.ModelDto;
import com.general.Model;
import com.service.ModelService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.List;
/**
* Created by kohtpojiep on 23.01.16.
*/
#RestController
public class ModelRestController
{
private static final Logger LOGGER = LogManager.getLogger();
#Autowired
private ModelService modelService;
#RequestMapping(value="/models", method = RequestMethod.GET)
public #ResponseBody List<Model> getAllModels()
{
LOGGER.debug("Getting all models");
return modelService.getAllModels();
}
#RequestMapping(value="/model", method = RequestMethod.POST)
#ResponseStatus(value = HttpStatus.CREATED)
public #ResponseBody Integer addModel(#RequestBody Model model)
{
LOGGER.debug("Adding model modelName = {}", model.getModelName());
return modelService.addModel(model);
}
#RequestMapping (value="/model/{modelId}/{modelName}", method=RequestMethod.PUT)
#ResponseStatus(value = HttpStatus.ACCEPTED)
public #ResponseBody void updateModel(#PathVariable(value="modelId") Integer modelId,
#PathVariable(value="modelName") String modelName)
{
LOGGER.debug("Updating model modelId = {}", modelId);
modelService.updateModel(new Model(modelId,modelName));
}
#RequestMapping (value="/model/{modelName}", method = RequestMethod.DELETE)
#ResponseStatus(value = HttpStatus.NO_CONTENT)
public #ResponseBody void deleteModelByName(#PathVariable(value = "modelName") String modelName)
{
LOGGER.debug("Deleting model modelName= {}",modelName);
modelService.deleteModelByName(modelName);
}
#RequestMapping (value="/modelsdto", method = RequestMethod.GET)
#ResponseStatus(value = HttpStatus.OK)
public #ResponseBody
ModelDto getModelsDto()
{
LOGGER.debug("Getting models Dto");
return modelService.getModelDto();
}
}
AutomobileRestController
package com.rest;
import com.dto.AutomobileDto;
import com.general.Automobile;
import com.service.AutomobileService;
import org.joda.time.LocalDate;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.List;
/**
* Created by kohtpojiep on 02.02.16.
*/
#RestController
public class AutomobileRestController
{
private static final Logger LOGGER = LogManager.getLogger();
#Autowired
AutomobileService automobileService;
private static LocalDate convertToLocalDate(String date)
{
DateTimeFormatter formattedDate = DateTimeFormat.forPattern("dd/MM/yyyy");
return formattedDate.parseLocalDate(date);
}
#RequestMapping(value = "/automobiles", method = RequestMethod.GET)
#ResponseStatus(value = HttpStatus.ACCEPTED)
public #ResponseBody List<Automobile> getAllAutomobiles()
{
LOGGER.debug("Getting all automobiles");
return automobileService.getAllAutomobiles();
}
#RequestMapping(value = "/automobile", method = RequestMethod.POST)
#ResponseStatus(value = HttpStatus.CREATED)
public #ResponseBody Integer addAutomobile (#RequestBody Automobile automobile)
{
LOGGER.debug("Adding automobile modelName = {}",automobile.getModelName());
return automobileService.addAutomobile(automobile);
}
#RequestMapping(value = "/automobile/update", method = RequestMethod.PUT)
#ResponseStatus(value = HttpStatus.ACCEPTED)
public #ResponseBody void updateAutomobile (#RequestBody Automobile automobile)
{
LOGGER.debug("Updating automobile automobileId = {}", automobile.getAutomobileId());
automobileService.updateAutomobile(automobile);
}
#RequestMapping(value = "/automobile/{automobileId}", method = RequestMethod.DELETE)
#ResponseStatus(value = HttpStatus.NO_CONTENT)
public #ResponseBody void depeteAutomobile (#PathVariable (value="automobileId")
Integer automobileId)
{
LOGGER.debug("Deleting automobile automobileId = {}",automobileId);
automobileService.deleteAutomobileById(automobileId);
}
#RequestMapping(value = "/automobiles/date-sort", method = RequestMethod.GET)
#ResponseStatus(value = HttpStatus.ACCEPTED)
public #ResponseBody List<Automobile> getAutomobilesSortedByDate (#RequestParam(value="firstDate")
String firstDate, #RequestParam (value="lastDate") String lastDate)
{
LOGGER.debug("Getting automobiles sorted by date:\n");
return automobileService.getAutomobilesSortedByDate(
convertToLocalDate(firstDate),convertToLocalDate(lastDate));
}
#RequestMapping(value = "/automobilesdto", method = RequestMethod.GET)
#ResponseStatus(value = HttpStatus.OK)
public #ResponseBody
AutomobileDto getAutomobileDto()
{
LOGGER.debug("Getting automobile DTO");
return automobileService.getAutomobileDto();
}
}
pom.xml
<?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">
<parent>
<artifactId>usermanagement</artifactId>
<groupId>com.epam.brest.course2015</groupId>
<version>1.0.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>app-rest</artifactId>
<name>${project.artifactId}</name>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>com.epam.brest.course2015</groupId>
<artifactId>app-service</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>8.1.16.v20140903</version>
<configuration>
<stopPort>9091</stopPort>
<stopKey>STOP</stopKey>
<webAppConfig>
<contextPath>/rest</contextPath>
<allowDuplicateFragmentNames>true</allowDuplicateFragmentNames>
</webAppConfig>
<scanIntervalSeconds>10</scanIntervalSeconds>
<connectors>
<connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">
<port>8081</port>
</connector>
</connectors>
</configuration>
</plugin>
</plugins>
</build>
</project>
I saw solutions for similar situations: people offer to change versions of used frameworks and up the search level of component scan, but it doesn't work for me.
Add dependency to your POM:
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
</dependency>
As you use dependency management in parent POM, there is no need to specify version.
Solved! The problem was I use not only jackson-core dependency, but also jackson databind, datatype and annotations and these dependencies had different versions: 2.7.1 for "core" and 2.4.3 for other ones. Now I use the same version for all of them and thus adding dependency had an affect. Thx for your help!)
I had the same problem. I used spring version 5.0.5.RELEASE and Jackson Core version 2.4.3.
I upgraded Jackson core up to 2.9.5 and it works now : exception "Error creating bean with name 'org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter' " dissapeared and my rest service works.
Before in my pom.xml :
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.4.3</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.4.3</version>
</dependency>
After :
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.5</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.5</version>
</dependency>
I hope it will help.
Yes. Using version 2.9.5 works:
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
<version>2.9.5</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.5</version>
<exclusions>
<exclusion>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-core</artifactId>
</exclusion>
<exclusion>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</exclusion>
</exclusions>
</dependency>
I'm using spring-webmvc: 5.0.12.RELEASE, if that helps.

The object doesn't get persisted in Hibernate 4

I configured Hibernate and Spring.
The config and Java class:
package com.dao.impl;
import com.dao.IPersonRepository;
import com.dao.impl.generic.GenericRepository;
import com.model.Person;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
/**
* Created by ramezanimatin on 8/18/2015.
*/
#Repository
public class PersonRepository extends GenericRepository<Person, Long> implements IPersonRepository {
}
package com.dao;
import com.dao.iGeneric.IGenericRepository;
import com.model.Person;
/**
* Created by ramezanimatin on 8/18/2015.
*/
public interface IPersonRepository extends IGenericRepository<Person, Long> {
}
package com.dao.iGeneric;
import java.io.Serializable;
/**
* Created by ramezanimatin on 8/23/2015.
*/
public abstract interface IGenericRepository<T, pk extends Serializable> {
public void save(T t);
public T loadByEntityId(pk id);
}
package com.dao.impl.generic;
import com.dao.iGeneric.IGenericRepository;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import java.io.Serializable;
/**
* Created by ramezanimatin on 8/23/2015.
*/
#Repository
public class GenericRepository<T, pk extends Serializable> implements IGenericRepository<T, pk> {
#Autowired(required = true)
private SessionFactory sessionFactory;
private Session getSession() {
try {
return sessionFactory.getCurrentSession();
} catch (Exception e) {
return sessionFactory.openSession();
}
}
#Override
public void save(Object o) {
getSession().save(o);
}
#Override
public T loadByEntityId(pk id) {
Session session = getSession();
Query query = session.createQuery("from Person e where e.id=:id");
query.setParameter("id", id);
return ((T) query.uniqueResult());
}
}
xml config:
<?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"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd">
<context:property-placeholder location="classpath:oracle-hibernate.properties"/>
<context:component-scan base-package="com"/>
<!-- <jee:jndi-lookup id="dataSource" jndi-name="test" />-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test"/>
<property name="username" value="root"/>
<property name="password" value="1234"/>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="packagesToScan" value="com.model"/>
<property name="hibernateProperties">
<props>
<prop key="hibernate.hbm2ddl.auto">create</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql"> ${hibernate.show_sql}</prop>
<prop key="hibernate.default_schema"> ${hibernate.default_schema}</prop>
<prop key="hibernate.connection.defaultNChar">true</prop> <!--Oracle need -->
<prop key="hibernate.connection.characterEncoding">UTF8</prop> <!--Oracle need -->
<prop key="hibernate.connection.charSet">UTF8</prop> <!--Oracle need -->
<prop key="hibernate.connection.useEncoding">true</prop> <!--Oracle need -->
<prop key="hibernate.transaction.factory_class" >${hibernate.transaction.factory_class}</prop>
<!-- <prop key="hibernate.transaction.manager_lookup_class" >${hibernate.transaction.manager_lookup_class}</prop>
<prop key="hibernate.current_session_context_class" >${hibernate.current_session_context_class}</prop>-->
</props>
</property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"
proxy-target-class="true"/>
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>
personService:
package com.service.impl;
import com.dao.IPersonRepository;
import com.model.Person;
import com.service.IPersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Created by ramezanimatin on 8/15/2015.
*/
#Service
public class PersonService implements IPersonService {
#Autowired(required = true)
private IPersonRepository iPersonRepository;
#Override
#Transactional
public void insertPerson(Person person) {
iPersonRepository.save(person);
}
#Override
#Transactional
public void loadByEntityId(Long id) {
Person person = iPersonRepository.loadByEntityId(id);
System.out.println(person.getName());
person.setName("matin");
}
}
pom.xml
<?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>org.test</groupId>
<artifactId>test</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>4.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>4.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>4.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-commons-annotations</artifactId>
<version>3.2.0.Final</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>4.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>4.1.2.Final</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.5.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.0.7.RELEASE</version>
</dependency>
<dependency>
<groupId>javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.12.0.GA</version>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>javax.persistence</artifactId>
<version>2.1.0</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2</version>
</dependency>
<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>1.1</version>
</dependency>
<!-- jpa lib-->
</dependencies>
<build>
<finalName>test</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
My problem:
In Hibernate the Object Model has 3 states:
1- Transient
2- Persistent
3- Detached
I want to clarify the following situation:
When Object Model is fetched from the DataBase, it is Persistent. In loadByEntityId of PersonService when the Person Entity is loaded, It isn't persistent. Why?
I changed name to 'Matin' but didn't commited to DataBase.
Updated:
Thanks to M. Deinum for explain subtle differences.
Please remove this method:
private Session getSession() {
try {
return sessionFactory.getCurrentSession();
} catch (Exception e) {
return sessionFactory.openSession();
}
}
and just invoke getCurrentSession() for example:
Session session = sessionFactory.getCurrentSession();
In this method:
#Override
#Transactional
public void loadByEntityId(Long id) {
Person person = iPersonRepository.loadByEntityId(id);
System.out.println(person.getName());
person.setName("matin");
}
you have found Person entity and it's pretty much done. Under the hood you are using session in Hibernate so this particular code:
Session session = sessionFactory.getCurrentSession();
Query query = session.createQuery("from Person e where e.id=:id");
query.setParameter("id", id);
return ((T) query.uniqueResult());
only retrieve data.
What you need to do is define update method in your repository IGenericRepository interface:
public abstract interface IGenericRepository<T, pk extends Serializable> {
public void save(T t);
public T loadByEntityId(pk id);
public void updateEntity(T t);
}
implement it in GenericRepository:
#Override
public void updateEntity(T entity) {
getSession().update(entity);
}
define in IPersonService method updatePerson and implement it in PersonService and use updateEntity from Repostitory:
#Override
#Transactional
public void updatePerson(Person person) {
iPersonRepository.updateEntity(person);
}
And now when you use loadByEntityId after you have updated Person with updatePerson you should retrieve updated entity from db.

Caching of default Spring Data JPA Methods

Task: make basic methods of spring jpa data cacheable (using hibernate/jpa), like
Page<T> findAll(Pageable pageable)
List<T> findAll();
etc
and do it on some kind of top generic interface level, without custom dao implementations.
This is continuation of original topic
How to add QueryHints on Default Spring Data JPA Methods?
I haven't still found the solution, but tried to solve it with different ways, including adding annotations like
#javax.persistence.Cacheable and #org.hibernate.annotations.Cache
on data model class.
Here are some excerpts of my config:
pom.xml (taken from here):
...
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<version>4.1.9.Final</version>
<exclusions>
<exclusion>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.7.0</version>
</dependency>
...
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.4.2.RELEASE</version>
</dependency>
...
applicationContext.xml:
<tx:annotation-driven mode="aspectj" transaction-manager="transactionManager"/>
<bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>
<bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory">
<property name="persistenceUnitName" value="persistenceUnit"/>
<property name="dataSource" ref="dataSource"/>
</bean>
persistence.xml:
...
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
<properties>
...
<property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory"/>
<property name="hibernate.cache.use_second_level_cache" value="true"/>
<property name="hibernate.cache.use_query_cache" value="true" />
</properties>
...
Apart from all above I have configured spring 3.2 cache, but eventually I want to have a solution not based on spring cache, so at the moment I don't use spring cache config.
My model looks like:
#Entity
#Table(name = "ABC")
#Cacheable(true)
#Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class ABC {
...
My parent generic DAO looks like:
public interface CacheableGenericDao<T, ID> extends JpaRepository<T, ID>, JpaSpecificationExecutor<T> {
List<T> findAll();
Page<T> findAll(Pageable pageable);
<S extends T> S save(S entity);
...
P.S. Here is one more useful link concerning the topic, but I do want use basic method names.
So what am I missing conceptually? Is there any approach at all or do I want too much?
this is how the things seem to go: jira.springsource.org/browse/DATAJPA-173

Resources