Spring data crud repository save method not able to save Java model in Redis cache - spring

We are trying to save a model into the Redis cache using the spring data crud repository. This model has one property which is a map like below.
private Map<String, StudentInfo> studentData = new HashMap<String, StudentInfo>();
And this StudentInfo model has another Map as a property as below:-
private Map<String, Set<Books>> stBooks = new HashMap<String, Set<Books>>();
So overall structure is like this:-
Student.java
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonRootName;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
#JsonRootName(value = "student")
#JsonInclude(Include.NON_NULL)
public class Student implements Serializable {
private static final long serialVersionUID = -2421290151039598746L;
private Map<String, StudentInfo> studentData = new HashMap<String, StudentInfo>();
#JsonCreator
public Student(#JsonProperty("studentData") Map<String, StudentInfo> aStudentData)
{
super();
this.setStudentData(aStudentData);
}
public void studentData(String aId, StudentInfo astudentData)
{
this.studentData.put(aId, astudentData);
}
public Map<String, StudentInfo> getStudentData()
{
return this.studentData;
}
private void setStudentData(Map<String, StudentInfo> aStudentData)
{
this.studentData = aStudentData;
}}
StudentInfo.java
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonRootName;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
#JsonRootName(value = "studentInfo")
#JsonInclude(Include.NON_NULL)
public class StudentInfo implements Serializable {
private static final long serialVersionUID = 6873987079436896955L;
String stName = null;;
private Map<String, Set<Books>> stBooks = new HashMap<String, Set<Books>>();
public StudentInfo(String stName)
{
super();
this.setDealerCode(stName);
}
#JsonCreator
public StudentInfo(#JsonProperty("stName") String aStName,
#JsonProperty("stBooks") Map<String, Set<Books>> aStBooks)
{
super();
this.setDealerCode(aStName);
this.setStBooks(aStBooks);
}
private void setStBooks(Map<String, Set<Books>> aStBooks)
{
this.stBooks = aStBooks;
}
public Map<String, Set<Books>> getStBooks()
{
return this.stBooks;
}
private void setDealerCode(String astName)
{
this.stName = astName;
}
public String getStName()
{
return this.stName;
}
#Override
public String toString() {
return "Student [StudentName=" + stName + "]";
}}
Books.java
import java.io.Serializable;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonRootName;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
#JsonRootName(value = "books")
#JsonInclude(Include.NON_NULL)
public class Books implements Serializable {
private static final long serialVersionUID = 1759477433483466736L;
private String bookName = null;
#JsonCreator
public Books(#JsonProperty("bookName") String aBookName)
{
super();
this.setBookName(aBookName);
}
public String getBookName() {
return bookName;
}
private void setBookName(String aBookName) {
this.bookName = aBookName;
}
public String toString()
{
return this.getBookName();
}}
StudenCacheModel.java
import java.io.Serializable;
import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;
import lombok.Getter;
import lombok.Setter;
#Getter
#Setter
#RedisHash(value = "StudentCache")
public class StudenCacheModel implements Serializable {
private static final long serialVersionUID = 9174813592532123048L;
#Id
String userId;
Student student;
}
Spring Crud Repository
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
#Repository
public interface StudenCacheRepository extends CrudRepository<StudenCacheModel, String> {
}
Saving the model using Crud Repo
StudenCacheModel studentCacheModel = new StudenCacheModel();
studentCacheModel.setSrudent(st); //student model set
studentCacheModel.setUserId(userId);
studentCacheRepository.save(studentCacheModel);
Exception:-
enter code hereorg.springframework.data.mapping.MappingException: Couldn't find
PersistentEntity for type class java.lang.Object!
Complete Stacktrace:-
org.springframework.data.mapping.MappingException: Couldn't find PersistentEntity for type class java.lang.Object!
at org.springframework.data.mapping.context.MappingContext.getRequiredPersistentEntity(MappingContext.java:79) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.writeInternal(MappingRedisConverter.java:621) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.writeMap(MappingRedisConverter.java:867) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.lambda$writeInternal$2(MappingRedisConverter.java:640) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.mapping.model.BasicPersistentEntity.doWithProperties(BasicPersistentEntity.java:360) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.writeInternal(MappingRedisConverter.java:624) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.writeMap(MappingRedisConverter.java:867) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.lambda$writeInternal$2(MappingRedisConverter.java:640) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.mapping.model.BasicPersistentEntity.doWithProperties(BasicPersistentEntity.java:360) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.writeInternal(MappingRedisConverter.java:624) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.writeMap(MappingRedisConverter.java:867) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.lambda$writeInternal$2(MappingRedisConverter.java:640) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.mapping.model.BasicPersistentEntity.doWithProperties(BasicPersistentEntity.java:360) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.writeInternal(MappingRedisConverter.java:624) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.lambda$writeInternal$2(MappingRedisConverter.java:666) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.mapping.model.BasicPersistentEntity.doWithProperties(BasicPersistentEntity.java:360) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.writeInternal(MappingRedisConverter.java:624) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.write(MappingRedisConverter.java:424) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.convert.MappingRedisConverter.write(MappingRedisConverter.java:114) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.RedisKeyValueAdapter.put(RedisKeyValueAdapter.java:215) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.keyvalue.core.KeyValueTemplate.lambda$update$1(KeyValueTemplate.java:221) ~[spring-data-keyvalue-2.6.1.jar:2.6.1]
at org.springframework.data.keyvalue.core.KeyValueTemplate.execute(KeyValueTemplate.java:362) ~[spring-data-keyvalue-2.6.1.jar:2.6.1]
at org.springframework.data.keyvalue.core.KeyValueTemplate.update(KeyValueTemplate.java:221) ~[spring-data-keyvalue-2.6.1.jar:2.6.1]
at org.springframework.data.redis.core.RedisKeyValueTemplate.update(RedisKeyValueTemplate.java:178) ~[spring-data-redis-2.6.1.jar:2.6.1]
at org.springframework.data.keyvalue.repository.support.SimpleKeyValueRepository.save(SimpleKeyValueRepository.java:80) ~[spring-data-keyvalue-2.6.1.jar:2.6.1]
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:na]
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:na]
at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:na]
at java.base/java.lang.reflect.Method.invoke(Method.java:566) ~[na:na]
at org.springframework.data.repository.core.support.RepositoryMethodInvoker$RepositoryFragmentMethodInvoker.lambda$new$0(RepositoryMethodInvoker.java:289) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.repository.core.support.RepositoryMethodInvoker.doInvoke(RepositoryMethodInvoker.java:137) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.repository.core.support.RepositoryMethodInvoker.invoke(RepositoryMethodInvoker.java:121) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.repository.core.support.RepositoryComposition$RepositoryFragments.invoke(RepositoryComposition.java:529) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.repository.core.support.RepositoryComposition.invoke(RepositoryComposition.java:285) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.repository.core.support.RepositoryFactorySupport$ImplementationMethodExecutionInterceptor.invoke(RepositoryFactorySupport.java:639) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.3.15.jar:5.3.15]
at org.springframework.data.repository.core.support.QueryExecutorMethodInterceptor.doInvoke(QueryExecutorMethodInterceptor.java:163) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.data.repository.core.support.QueryExecutorMethodInterceptor.invoke(QueryExecutorMethodInterceptor.java:138) ~[spring-data-commons-2.6.1.jar:2.6.1]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.3.15.jar:5.3.15]
at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:97) ~[spring-aop-5.3.15.jar:5.3.15]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.3.15.jar:5.3.15]
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:215) ~[spring-aop-5.3.15.jar:5.3.15]
at com.sun.proxy.$Proxy163.save(Unknown Source) ~[na:na]
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:na]
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:na]
at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:na]
at java.base/java.lang.reflect.Method.invoke(Method.java:566) ~[na:na]
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:344) ~[spring-aop-5.3.15.jar:5.3.15]
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:198) ~[spring-aop-5.3.15.jar:5.3.15]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163) ~[spring-aop-5.3.15.jar:5.3.15]
at org.springframework.dao.support.PersistenceExceptionTranslationInterceptor.invoke(PersistenceExceptionTranslationInterceptor.java:137) ~[spring-tx-5.3.15.jar:5.3.15]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.3.15.jar:5.3.15]
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:215) ~[spring-aop-5.3.15.jar:5.3.15]
at com.sun.proxy.$Proxy163.save(Unknown Source) ~[na:na]
Q1 - Is it the limitation of Spring data redis as we are able to save the same model using JEDIS library.
Any help/input will be highly apperciated !!

With a few small changes I got your example working:
In the POM used Spring Boot 2.6.4 and Java 11:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-annotations</artifactId>
</dependency>
Added a no-args constructor to StudentInfo
Added Lombok #ToString1 to StudenCacheModel
Modified Student to have method params that Jackson reflection could use:
#JsonRootName(value = "student")
#JsonInclude(Include.NON_NULL)
public class Student implements Serializable {
private static final long serialVersionUID = -2421290151039598746L;
private Map<String, StudentInfo> studentData = new HashMap<String, StudentInfo>();
#JsonCreator
public Student(#JsonProperty("studentData") Map<String, StudentInfo> studentData) {
super();
this.setStudentData(studentData);
}
public void studentData(String aId, StudentInfo studentData) {
this.studentData.put(aId, studentData);
}
public Map<String, StudentInfo> getStudentData() {
return this.studentData;
}
private void setStudentData(Map<String, StudentInfo> studentData) {
this.studentData = studentData;
}
}
Added a simple test with a runner on the main app:
#SpringBootApplication
public class SodemoApplication {
#Bean
CommandLineRunner testRepo(StudenCacheRepository studentCacheRepository) {
return args -> {
StudenCacheModel studentCacheModel = new StudenCacheModel();
StudentInfo si = new StudentInfo("bsb");
Student st = new Student(Map.of("bsb", si));
studentCacheModel.setStudent(st); //student model set
studentCacheRepository.save(studentCacheModel);
studentCacheRepository.findAll().forEach(System.out::println);
};
}
public static void main(String[] args) {
SpringApplication.run(SodemoApplication.class, args);
}
}
Running it you get the console output:
[2m2022-03-09 10:07:19.087[0;39m [32m INFO[0;39m [35m19669[0;39m [2m---[0;39m [2m[ main][0;39m [36mcom.example.sodemo.SodemoApplication [0;39m [2m:[0;39m Started SodemoApplication in 1.134 seconds (JVM running for 1.734)
StudenCacheModel(userId=19028f97-3e10-4776-8777-4a8cee224baf, student=com.example.sodemo.Student#24e5389c)
And on the Redis CLI you can see:
127.0.0.1:6379> keys *
1) "StudentCache"
2) "StudentCache:19028f97-3e10-4776-8777-4a8cee224baf"
127.0.0.1:6379> TYPE "StudentCache:19028f97-3e10-4776-8777-4a8cee224baf"
hash
127.0.0.1:6379> HGETALL "StudentCache:19028f97-3e10-4776-8777-4a8cee224baf"
1) "_class"
2) "com.example.sodemo.StudenCacheModel"
3) "student.studentData.[bsb].stName"
4) "bsb"
5) "userId"
6) "19028f97-3e10-4776-8777-4a8cee224baf"
127.0.0.1:6379>
I've created a repo with the full running example at https://github.com/bsbodden/sodemo
BTW Spring Data Redis uses Lettuce by default unless you configure it to use Jedis; both drivers can be used to save #RedisHash annotated entities

Related

Extending ReactiveQueryByExampleExecutor throws PropertyReferenceException

I'm having an issue with trying to implement ReactiveQueryByExampleExecutor into my repository in my application
Stack trace:
Caused by: java.lang.IllegalArgumentException: Failed to create query for method public abstract reactor.core.publisher.Mono org.springframework.data.repository.query.ReactiveQueryByExampleExecutor.exists(org.springframework.data.domain.Example)! No property exists found for type Solution!
at org.springframework.data.r2dbc.repository.query.PartTreeR2dbcQuery.<init>(PartTreeR2dbcQuery.java:70)
at org.springframework.data.r2dbc.repository.support.R2dbcRepositoryFactory$R2dbcQueryLookupStrategy.resolveQuery(R2dbcRepositoryFactory.java:187)
at org.springframework.data.repository.core.support.QueryExecutorMethodInterceptor.lookupQuery(QueryExecutorMethodInterceptor.java:99)
at org.springframework.data.repository.core.support.QueryExecutorMethodInterceptor.lambda$mapMethodsToQuery$1(QueryExecutorMethodInterceptor.java:92)
at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:195)
at java.base/java.util.Iterator.forEachRemaining(Iterator.java:133)
at java.base/java.util.Collections$UnmodifiableCollection$1.forEachRemaining(Collections.java:1052)
at java.base/java.util.Spliterators$IteratorSpliterator.forEachRemaining(Spliterators.java:1801)
at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:484)
at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:474)
at java.base/java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:913)
at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
at java.base/java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:578)
at org.springframework.data.repository.core.support.QueryExecutorMethodInterceptor.mapMethodsToQuery(QueryExecutorMethodInterceptor.java:94)
at org.springframework.data.repository.core.support.QueryExecutorMethodInterceptor.lambda$new$0(QueryExecutorMethodInterceptor.java:84)
at java.base/java.util.Optional.map(Optional.java:265)
at org.springframework.data.repository.core.support.QueryExecutorMethodInterceptor.<init>(QueryExecutorMethodInterceptor.java:84)
at org.springframework.data.repository.core.support.RepositoryFactorySupport.getRepository(RepositoryFactorySupport.java:332)
at org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport.lambda$afterPropertiesSet$5(RepositoryFactoryBeanSupport.java:297)
at org.springframework.data.util.Lazy.getNullable(Lazy.java:211)
at org.springframework.data.util.Lazy.get(Lazy.java:95)
at org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport.afterPropertiesSet(RepositoryFactoryBeanSupport.java:300)
at org.springframework.data.r2dbc.repository.support.R2dbcRepositoryFactoryBean.afterPropertiesSet(R2dbcRepositoryFactoryBean.java:143)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1853)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1790)
... 70 more
Caused by: org.springframework.data.mapping.PropertyReferenceException: No property exists found for type Solution!
at org.springframework.data.mapping.PropertyPath.<init>(PropertyPath.java:94)
at org.springframework.data.mapping.PropertyPath.create(PropertyPath.java:382)
at org.springframework.data.mapping.PropertyPath.create(PropertyPath.java:358)
at org.springframework.data.mapping.PropertyPath.lambda$from$0(PropertyPath.java:311)
at java.base/java.util.concurrent.ConcurrentMap.computeIfAbsent(ConcurrentMap.java:330)
at org.springframework.data.mapping.PropertyPath.from(PropertyPath.java:293)
at org.springframework.data.mapping.PropertyPath.from(PropertyPath.java:276)
at org.springframework.data.repository.query.parser.Part.<init>(Part.java:82)
at org.springframework.data.repository.query.parser.PartTree$OrPart.lambda$new$0(PartTree.java:251)
at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:195)
at java.base/java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:177)
at java.base/java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:484)
at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:474)
at java.base/java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:913)
at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
at java.base/java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:578)
at org.springframework.data.repository.query.parser.PartTree$OrPart.<init>(PartTree.java:252)
at org.springframework.data.repository.query.parser.PartTree$Predicate.lambda$new$0(PartTree.java:381)
at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:195)
at java.base/java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:177)
at java.base/java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:948)
at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:484)
at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:474)
at java.base/java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:913)
at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
at java.base/java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:578)
at org.springframework.data.repository.query.parser.PartTree$Predicate.<init>(PartTree.java:382)
at org.springframework.data.repository.query.parser.PartTree.<init>(PartTree.java:94)
at org.springframework.data.r2dbc.repository.query.PartTreeR2dbcQuery.<init>(PartTreeR2dbcQuery.java:66)
... 94 more
Repo :
import org.springframework.data.repository.query.ReactiveQueryByExampleExecutor;
import org.springframework.data.repository.reactive.ReactiveSortingRepository;
public interface MeetingSolverRepository extends ReactiveSortingRepository<Solution, Long>, ReactiveQueryByExampleExecutor<Solution> {
}
Service :
#Slf4j
#Service
#RequiredArgsConstructor
public class MeetingSolverServiceImpl implements MeetingSolverService {
private final MeetingSolverRepository meetingSolverRepository;
#Override
public Flux<Solution> findAll(Solution solution) {
Example<Solution> example = Example.of(solution);
return meetingSolverRepository.findAll(example);
}
}
Object :
import lombok.Data;
import org.springframework.data.annotation.Id;
#Data
public class Solution {
#Id
private Long id;
private Integer tenant;
private Long meetingId;
private Long periodId;
private Long studentId;
private Long teacherId;
private Long roomId;
}
DB config :
import dev.miku.r2dbc.mysql.MySqlConnectionConfiguration;
import dev.miku.r2dbc.mysql.MySqlConnectionFactory;
import io.r2dbc.spi.ConnectionFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.r2dbc.config.AbstractR2dbcConfiguration;
import org.springframework.data.r2dbc.connectionfactory.R2dbcTransactionManager;
import org.springframework.data.r2dbc.core.DatabaseClient;
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
import org.springframework.lang.NonNull;
import org.springframework.transaction.ReactiveTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.reactive.TransactionalOperator;
#Configuration
#EnableR2dbcRepositories
#EnableTransactionManagement
public class R2DBCConfiguration extends AbstractR2dbcConfiguration {
#Value("${spring.datasource.host}") private String host;
#Value("${spring.datasource.port}") private Integer port;
#Value("${spring.datasource.schema-name}") private String database;
#Value("${spring.datasource.username}") private String username;
#Value("${spring.datasource.password}") private String password;
#Bean
#NonNull
#Override
public ConnectionFactory connectionFactory() {
return MySqlConnectionFactory.from(
MySqlConnectionConfiguration.builder()
.host(host)
.port(port)
.user(username)
.password(password)
.database(database)
.build());
}
#Bean({"r2dbcDatabaseClient"})
#Primary
public DatabaseClient databaseClient() {
return DatabaseClient.create(connectionFactory());
}
#Bean
public ReactiveTransactionManager reactiveTransactionManager(ConnectionFactory connectionFactory) {
return new R2dbcTransactionManager(connectionFactory);
}
#Bean
public TransactionalOperator transactionalOperator(ReactiveTransactionManager reactiveTransactionManager) {
return TransactionalOperator.create(reactiveTransactionManager);
}
}
It looks like it's checking the solution object for the exists property and count and so on.
I'm assuming I'm missing something in my setup?
Any help would be greatly appreciated. Thank you.
I don't think Spring Data R2DBC org.springframework.data.r2dbc.repository.support.SimpleR2dbcRepository implements the ReactiveQueryByExampleExecutor
Unlike its non-reactive counterpart SimpleJpaRepository in Spring Data JPA that implements the non-reactive QueryByExampleExecutor
Extending your repository interfaces using ReactiveQueryByExampleExecutor interface and expecting Springboot to auto-configure a ReactiveQueryByExampleExecutor implementation will NOT work (as of Spring Data R2DBC 1.0) and Spring Data will assume the unimplemented methods from ReactiveQueryByExampleExecutor are entity property queries hence the exception.
The solutions may be either
a) Implement your own ReactiveQueryByExampleExecutor based on your requirements,
b) switch to Spring Data Mongo if it is an option, or
c) wait for the community to implement a solution. I believe there is an open issue in Github for this. Good luck!

java.lang.NullPointerException what I'm doing wrong?

I'm working on a project in which my intention is to run a Corn job and send mail to my friends to wishing them on their birthday, I was able to get email from MySQL DB and compared it to the current date but when it comes to sending an email I'm getting NullPointerException.
I'm sure there is no problem with application properties I used them with other projects as well and they are function properly
//Imports
package dev.teja.happybirthday;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.*;
import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import javax.persistence.*;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.validation.constraints.Email;
import freemarker.template.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.ui.freemarker.FreeMarkerTemplateUtils;
import org.springframework.web.bind.annotation.*;
//Main
#SpringBootApplication
public class HappybirthdayApplication {
public static void main(String[] args) {
SpringApplication.run(HappybirthdayApplication.class, args);
}
#Autowired
MyFriendsRepository myFriendsRepository ;
#Scheduled(cron = "*/30 * * * * *")
void WishMyFriends() {
List<MyFriends> myFriendsList = myFriendsRepository.findAll();
myFriendsList.forEach(friend -> {
Date date = new Date();
SimpleDateFormat formatter = new SimpleDateFormat("dd/MM");
String CurrentDate= formatter.format(date);
String GivenDate = formatter.format(friend.dob);
if (GivenDate.equals(CurrentDate)){
Job job = new Job();
Map<String, Object> model = new HashMap<>();
model.put("Name",friend.name);
job.sendWish(friend.email,model);
}
});
}
}
#Configuration
#ConditionalOnProperty(name = "scheduling.enabled", matchIfMissing = true)
#EnableScheduling
class Tasks {
}
//Model
#Data
#Setter
#Getter
#NoArgsConstructor
#AllArgsConstructor
#ToString
#Entity
class MyFriends {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
Long id;
String name;
#Email
#Column(unique = true)
String email;
#JsonFormat(pattern = "dd/MM/yyyy", shape = JsonFormat.Shape.STRING)
Date dob;
Long phoneNumber;
}
//Repository
interface MyFriendsRepository extends JpaRepository<MyFriends, Long> {
}
#RestController
#RequestMapping("/")
class FriendsController {
#Autowired
MyFriendsRepository myFriendsRepository;
#PostMapping("/friends")
ResponseEntity<MyFriends> createFriend(#RequestBody MyFriends myFriend) {
myFriendsRepository.save(myFriend);
return new ResponseEntity<MyFriends>(myFriend, HttpStatus.CREATED);
}
#GetMapping("/friends")
List<MyFriends> getFriends() {
return myFriendsRepository.findAll();
}
}
//Interface
interface wisher{
void sendWish(String email, Map<String, Object> model);
}
//Implementation
#Service
class Job implements wisher{
#Autowired
private JavaMailSender sender;
#Autowired
private freemarker.template.Configuration config;
#Override
public void sendWish(String email,Map<String, Object> model) {
System.out.println("wishes sent to "+ email);
MimeMessage message = sender.createMimeMessage();
try {
MimeMessageHelper helper = new MimeMessageHelper(message, MimeMessageHelper.MULTIPART_MODE_MIXED_RELATED,
StandardCharsets.UTF_8.name());
Template template = config.getTemplate("new-template.ftl");
String html = FreeMarkerTemplateUtils.processTemplateIntoString(template, model);
helper.setTo(email);
helper.setFrom("kondasaitej#gmail.com");
helper.setSubject("Happy Birthday");
helper.setText(html,true);
sender.send(message);
} catch (MessagingException | IOException | TemplateException e) {
e.printStackTrace();
}
}
}
FreeMaker file in ./resources/Templates
/**
* FREEMAKER new-template.ftl
* <html xmlns="http://www.w3.org/1999/xhtml">
* <head>
* <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
* <title>Comment Alert Mail</title>
* </head>
* <body>
* <p>happy birthday ${Name}</p>
* </body>
*/
This is the error I'm getting this following
Hibernate: select myfriends0_.id as id1_0_, myfriends0_.dob as dob2_0_, myfriends0_.email as email3_0_, myfriends0_.name as name4_0_, myfriends0_.phone_number as phone_nu5_0_ from my_friends myfriends0_
wishes sent to kondasaitej#protonmail.com
2020-09-26 21:01:52.012 ERROR 84242 --- [ scheduling-1] o.s.s.s.TaskUtils$LoggingErrorHandler : Unexpected error occurred in scheduled task
java.lang.NullPointerException: null
at dev.teja.happybirthday.Job.sendWish(HappybirthdayApplication.java:115) ~[classes/:na]
at dev.teja.happybirthday.HappybirthdayApplication.lambda$WishMyFriends$0(HappybirthdayApplication.java:53) ~[classes/:na]
at java.util.ArrayList.forEach(ArrayList.java:1257) ~[na:1.8.0_251]
at dev.teja.happybirthday.HappybirthdayApplication.WishMyFriends(HappybirthdayApplication.java:44) ~[classes/:na]
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_251]
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_251]
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_251]
at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_251]
at org.springframework.scheduling.support.ScheduledMethodRunnable.run(ScheduledMethodRunnable.java:84) ~[spring-context-5.2.9.RELEASE.jar:5.2.9.RELEASE]
at org.springframework.scheduling.support.DelegatingErrorHandlingRunnable.run(DelegatingErrorHandlingRunnable.java:54) ~[spring-context-5.2.9.RELEASE.jar:5.2.9.RELEASE]
at org.springframework.scheduling.concurrent.ReschedulingRunnable.run(ReschedulingRunnable.java:93) [spring-context-5.2.9.RELEASE.jar:5.2.9.RELEASE]
at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511) [na:1.8.0_251]
at java.util.concurrent.FutureTask.run(FutureTask.java:266) [na:1.8.0_251]
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$201(ScheduledThreadPoolExecutor.java:180) [na:1.8.0_251]
at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:293) [na:1.8.0_251]
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149) [na:1.8.0_251]
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624) [na:1.8.0_251]
at java.lang.Thread.run(Thread.java:748) [na:1.8.0_251]
Try add getting in the #Autowired private JavaMailSender sender;
I think you have not implemented your JavaMailSender bean. Define a bean like below. Then your #Autowire annotation will work.
#Bean
public JavaMailSender getJavaMailSender()
{
JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
mailSender.setHost("smtp.gmail.com");
mailSender.setPort(25);
mailSender.setUsername("admin#gmail.com");
mailSender.setPassword("password");
Properties props = mailSender.getJavaMailProperties();
props.put("mail.transport.protocol", "smtp");
props.put("mail.smtp.auth", "true");
props.put("mail.smtp.starttls.enable", "true");
props.put("mail.debug", "true");
return mailSender;
}

Spring CRUD App: Servlet.service() for servlet [dispatcherServlet] : java.lang.NullPointerException]

I've a problem to get employees data from mySQL db. According to logs there is a problem at line: 36 in my EmployeeServiceImpl.listEmployess metod.
Logs:
2018-10-18 16:07:42.871 ERROR 1504 --- [nio-8090-exec-4] o.a.c.c.C.[.[.[/].[dispatcherServlet] : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.NullPointerException] with root cause
java.lang.NullPointerException: null
at com.project.service.EmployeeServiceImpl.listEmployess(EmployeeServiceImpl.java:36) ~[classes/:na]
com.project.service.EmployeeServiceImpl$$FastClassBySpringCGLIB$$c7d76ecc.invoke() ~[classes/:na]
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) ~[spring-core-5.0.9.RELEASE.jar:5.0.9.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:746) ~[spring-aop-5.0.9.RELEASE.jar:5.0.9.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:163) ~[spring-aop-5.0.9.RELEASE.jar:5.0.9.RELEASE]
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:294) ~[spring-tx-5.0.9.RELEASE.jar:5.0.9.RELEASE]
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:98) ~[spring-tx-5.0.9.RELEASE.jar:5.0.9.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:185) ~[spring-aop-5.0.9.RELEASE.jar:5.0.9.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:688) ~[spring-aop-5.0.9.RELEASE.jar:5.0.9.RELEASE]
at com.project.service.EmployeeServiceImpl$$EnhancerBySpringCGLIB$$1390ca06.listEmployess() ~[classes/:na]
at com.project.controller.EmployeeController.listEmployess(EmployeeController.java:34) ~[classes/:na]
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) ~[na:1.8.0_161]
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62) ~[na:1.8.0_161]
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_161]
at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_161]
EmployeeServiceImpl:
package com.project.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.project.dao.EmployeeDAO;
import com.project.entity.TEmployee;
#Service("employeeService")
public class EmployeeServiceImpl implements EmployeeService {
private EmployeeDAO employeeDAO;
public void setEmployeeDAO(EmployeeDAO employeeDAO) {
this.employeeDAO = employeeDAO;
}
#Override
#Transactional
public void addEmployee(TEmployee p) {
this.employeeDAO.addEmployee(p);
}
#Override
#Transactional
public void updateEmployee(TEmployee p) {
this.employeeDAO.updateEmployee(p);
}
#Override
#Transactional
public List<TEmployee> listEmployess() {
return this.employeeDAO.listEmployess();
}
#Override
#Transactional
public TEmployee getEmployeeById(int employee_id) {
return this.employeeDAO.getEmployeeById(employee_id);
}
#Override
#Transactional
public void removeEmployee(int employee_id) {
this.employeeDAO.removeEmployee(employee_id);
}
}
EmployeeService:
package com.project.service;
import java.util.List;
import org.springframework.context.annotation.ComponentScan;
import com.project.entity.TEmployee;
#ComponentScan(basePackages= {"com.project.*"})
public interface EmployeeService {
public void addEmployee(TEmployee p);
public void updateEmployee(TEmployee p);
public List<TEmployee> listEmployess();
public TEmployee getEmployeeById(int id);
public void removeEmployee(int id);
}
EmployeeDAO:
package com.project.dao;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import com.project.entity.TEmployee;
#ComponentScan(basePackages= {"com.project.*"})
public interface EmployeeDAO {
public void addEmployee(TEmployee p);
public void updateEmployee(TEmployee p);
public List<TEmployee> listEmployess();
public TEmployee getEmployeeById(int employee_id);
public void removeEmployee(int employee_id);
}
EmployeeDAOImpl:
package com.project.dao;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.project.entity.TEmployee;
#Repository
public class EmployeeDAOImpl implements EmployeeDAO {
private static final Logger logger = LoggerFactory.getLogger(EmployeeDAOImpl.class);
private SessionFactory sessionFactory;
public void setSessionFactory(SessionFactory sf){
this.sessionFactory = sf;
}
#Override
public void addEmployee(TEmployee p) {
Session session = this.sessionFactory.getCurrentSession();
session.persist(p);
logger.info("TEmployee saved successfully, TEmployee Details="+p);
}
#Override
public void updateEmployee(TEmployee p) {
Session session = this.sessionFactory.getCurrentSession();
session.update(p);
logger.info("TEmployee updated successfully, TEmployee Details="+p);
}
#SuppressWarnings("unchecked")
#Override
public List<TEmployee> listEmployess() {
Session session = this.sessionFactory.getCurrentSession();
List<TEmployee> EmployessList = session.createQuery("from TEmployee").list();
for(TEmployee p : EmployessList){
logger.info("TEmployee List::"+p);
}
return EmployessList;
}
#Override
public TEmployee getEmployeeById(int employee_id) {
Session session = this.sessionFactory.getCurrentSession();
TEmployee p = (TEmployee) session.load(TEmployee.class, new Integer(employee_id));
logger.info("TEmployee loaded successfully, TEmployee details="+p);
return p;
}
#Override
public void removeEmployee(int employee_id) {
Session session = this.sessionFactory.getCurrentSession();
TEmployee p = (TEmployee) session.load(TEmployee.class, new Integer(employee_id));
if(null != p){
session.delete(p);
}
logger.info("TEmployee deleted successfully, TEmployee details="+p);
}
}
And EmployeeController:
package com.project.controller;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.project.entity.TEmployee;
import com.project.service.EmployeeService;
#ComponentScan(basePackages= {"com.project.*"})
#Controller
public class EmployeeController {
#Resource(name = "employeeService")
private EmployeeService employeeService;
#Autowired(required=true)
#Qualifier(value="employeeService")
public void setEmployeeService(EmployeeService ps){
this.employeeService = ps;
}
#RequestMapping(value = "/employess", method = RequestMethod.GET)
public String listEmployess(Model model) {
model.addAttribute("employee", new TEmployee());
model.addAttribute("listEmployess", this.employeeService.listEmployess());
return "employee";
}
//For add and update person both
#RequestMapping(value= "/employee/add", method = RequestMethod.POST)
public String addEmployee(#ModelAttribute("employee") TEmployee p){
if(p.getEmployeeID() == 0){
//new person, add it
this.employeeService.addEmployee(p);
}else{
//existing person, call update
this.employeeService.updateEmployee(p);
}
return "redirect:/employess";
}
#RequestMapping("/remove/{employee_id}")
public String removeEmployee(#PathVariable("employee_id") int employee_id){
this.employeeService.removeEmployee(employee_id);
return "redirect:/employess";
}
#RequestMapping("/edit/{employee_id}")
public String editEmployee(#PathVariable("employee_id") int employee_id, Model model){
model.addAttribute("employee", this.employeeService.getEmployeeById(employee_id));
model.addAttribute("listEmployess", this.employeeService.listEmployess());
return "employee";
}
}
So, according to logs there is a NPE returning from this line:
return this.employeeDAO.listEmployess();
Do you have any idea what could be wrong here?
Thanks in advance!
Hi instead of setter method use Autowired annotation on dependency private EmployeeDAO employeeDAO;
like
#Autowired
private EmployeeDAO employeeDAO;

at org.hibernate.hql.internal.ast.QuerySyntaxException.generateQueryException: model class is not mapped

I am new to SpringBoot. I am writing a project in SpringBoot(along with Hibernate)
while accessing the database, I am getting following error:
org.hibernate.hql.internal.ast.QuerySyntaxException: HashMapping is not mapped [from HashMapping where consumerUserId=:consumerUserId]
at org.hibernate.hql.internal.ast.QuerySyntaxException.generateQueryException(QuerySyntaxException.java:79) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.QueryException.wrapWithQueryString(QueryException.java:103) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.hql.internal.ast.QueryTranslatorImpl.doCompile(QueryTranslatorImpl.java:218) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.hql.internal.ast.QueryTranslatorImpl.compile(QueryTranslatorImpl.java:142) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.engine.query.spi.HQLQueryPlan.<init>(HQLQueryPlan.java:115) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.engine.query.spi.HQLQueryPlan.<init>(HQLQueryPlan.java:76) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.engine.query.spi.QueryPlanCache.getHQLQueryPlan(QueryPlanCache.java:150) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.internal.AbstractSessionImpl.getHQLQueryPlan(AbstractSessionImpl.java:302) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.internal.AbstractSessionImpl.createQuery(AbstractSessionImpl.java:240) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at org.hibernate.internal.SessionImpl.createQuery(SessionImpl.java:1894) ~[hibernate-core-5.0.12.Final.jar:5.0.12.Final]
at com.thp.clinic.tataInsurance.dao.InsuranceDaoImpl.userHashExists(InsuranceDaoImpl.java:24) ~[classes/:na]
at com.thp.clinic.tataInsurance.dao.InsuranceDaoImpl$$FastClassBySpringCGLIB$$f257a089.invoke(<generated>) [classes/:na]
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) [spring-core-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:738) [spring-aop-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) [spring-aop-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.dao.support.PersistenceExceptionTranslationInterceptor.invoke(PersistenceExceptionTranslationInterceptor.java:136) [spring-tx-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) [spring-aop-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:673) [spring-aop-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at com.thp.clinic.tataInsurance.dao.InsuranceDaoImpl$$EnhancerBySpringCGLIB$$87c1fe8a.userHashExists(<generated>) [classes/:na]
at com.thp.clinic.tataInsurance.service.InsuranceServiceImpl.checkInsurance(InsuranceServiceImpl.java:32) [classes/:na]
at com.thp.clinic.tataInsurance.service.InsuranceServiceImpl$$FastClassBySpringCGLIB$$31bac4e9.invoke(<generated>) [classes/:na]
at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) [spring-core-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:738) [spring-aop-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) [spring-aop-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99) [spring-tx-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:282) [spring-tx-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96) [spring-tx-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) [spring-aop-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:673) [spring-aop-4.3.13.RELEASE.jar:4.3.13.RELEASE]
at com.thp.clinic.tataInsurance.service.InsuranceServiceImpl$$EnhancerBySpringCGLIB$$49b68a9f.checkInsurance(<generated>) [classes/:na]
at com.thp.clinic.tataInsurance.controller.InsuranceController.checkInsurance(InsuranceController.java:31) [classes/:na]
My application.properties is as follows:
server.port=8080
spring.jpa.database=POSTGRESQL
spring.datasource.platform=postgres
spring.database.driverClassName=org.postgresql.Driver
spring.datasource.url=jdbc:postgresql://localhost:5432/INSURANCE_DB
spring.datasource.username=postgres
spring.datasource.password=postgres
spring.jpa.show-sql=true
#spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.hibernate.ddl-auto = update
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
spring.jpa.properties.hibernate.current_session_context_class=org.springframework.orm.hibernate5.SpringSessionContext
#auth protected here
endpoints.shutdown.sensitive=false
#Enable shutdown endpoint
endpoints.shutdown.enabled=true
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type=TRACE
My Application configuration class is as follows:
import org.hibernate.SessionFactory;
import org.hibernate.jpa.HibernateEntityManagerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
#SpringBootApplication()
#ComponentScan(basePackages = { "com.clinic.Insurance" })
public class Application {
#Bean
public SessionFactory sessionFactory(HibernateEntityManagerFactory hemf) {
return hemf.getSessionFactory();
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
The Dao is as follows:
#Override
public String userHashExists(Long consumerUserId) throws Exception{
Session session = null;
try {
session = factory.openSession();
Query query = session.createQuery("from HashMapping where consumerUserId=:consumerUserId");
query.setParameter("consumerUserId", consumerUserId);
HashMapping mapping = (HashMapping) query.uniqueResult();
if(mapping!=null)
return mapping.getConsumerHash();
return null;
} catch(Exception e){
logger.error("Exception in userHashExists Dao", e);
throw e;
} finally {
if(session!=null) {
session.close();
}
}
}
The Model/persistance class is as follows:
package com.clinic.Insurance.persistance;
import java.sql.Timestamp;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
#Entity
#Table(name = "hash_mapping")
public class HashMapping {
#Id
#GeneratedValue(strategy = GenerationType.AUTO, generator = "auto_gen")
#SequenceGenerator(name = "auto_gen", sequenceName = "hash_mapping_hash_mapping_id_seq")
#Column(name = "hash_mapping_id")
private Long hashMappingId;
#Column(name = "consumer_user_id")
private Long consumerUserId;
#Column(name = "consumer_hash")
private String consumerHash;
#Column(name = "modified_timestamp")
#Temporal(TemporalType.TIMESTAMP)
private Timestamp modifiedTimestamp;
public Long getHashMappingId() {
return hashMappingId;
}
public void setHashMappingId(Long hashMappingId) {
this.hashMappingId = hashMappingId;
}
public Long getConsumerUserId() {
return consumerUserId;
}
public void setConsumerUserId(Long consumerUserId) {
this.consumerUserId = consumerUserId;
}
public String getConsumerHash() {
return consumerHash;
}
public void setConsumerHash(String consumerHash) {
this.consumerHash = consumerHash;
}
public Timestamp getModifiedTimestamp() {
return modifiedTimestamp;
}
public void setModifiedTimestamp(Timestamp modifiedTimestamp) {
this.modifiedTimestamp = modifiedTimestamp;
}
}
Can someone please help where I am going wrong.
DO I need to define something like <hibernate-mapping package="it.besmart.models"> as we do in spring servelet configuration. If yes how to do it in my existing code?
Answering where I was going wrong.
Add #EntityScan(basePackages = { "youentitypackage" }) along with #ComponentScan(basePackages = { "com.app" }). This will look for your entity classes.
I think this mistake "Query query = session.createQuery("from HashMapping where consumerUserId=:consumerUserId");"When make a request to the database,need add "SELECT" your entity in table WHERE....
OR "HashMapping" to "hash_mapping" (class entity must be same name as database)

400 Bad Request using RestTemplete and postForObject

i'm building two applications using Spring 3.The first one is meant to be rest API and the second is a client.The client must create a reservation. I'm getting 400 Bad Request error,please help.
The class Reservation in the client app:
package ma.ensias.agencecentrale.entities;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.codehaus.jackson.annotate.JsonIgnore;
import org.codehaus.jackson.annotate.JsonIgnoreProperties;
import org.codehaus.jackson.annotate.JsonProperty;
#JsonIgnoreProperties(ignoreUnknown=true)
#Entity
#Table(name="reservations")
public class Reservation implements Serializable{
#Id
#GeneratedValue(strategy=GenerationType.IDENTITY)
private Long idReservation;
private String date;
#ManyToOne
#JoinColumn(name="id_utilisateur")
private Utilisateur utilisateur;
#JsonIgnore
#ManyToMany(cascade=CascadeType.ALL)
#JoinTable(name="passager_reservation", joinColumns=#JoinColumn(name="id_reservation"), inverseJoinColumns=#JoinColumn(name="id_passager"))
private Collection<Passager> passagers;
#JsonIgnore
#ManyToMany(cascade=CascadeType.ALL)
#JoinTable(name="vol_reservation", joinColumns=#JoinColumn(name="id_reservation"), inverseJoinColumns=#JoinColumn(name="id_vol"))
private Collection<Vol> vols;
// Contructor without fields
public Reservation() {
super();
}
// contructor with date attribute
public Reservation(String date) {
super();
this.date = date;
}
// ----------------------- Getters and setters-------------------------------
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
#JsonProperty(value="client")
public Utilisateur getUtilisateur() {
return utilisateur;
}
public void setUtilisateur(Utilisateur utilisateur) {
this.utilisateur = utilisateur;
}
public Collection<Vol> getVols() {
return vols;
}
public void setVols(Collection<Vol> vols) {
this.vols = vols;
}
public Long getIdReservation() {
return idReservation;
}
}
the rest Client :
//-------------------Create a Reservation--------------------------------------------------------
#RequestMapping("/ajouterReservation")
private static void ajouterReservation(Reservation reservation) {
RestTemplate restTemplate = new RestTemplate();
Reservation addedRes = restTemplate.postForObject(REST_SERVICE_URI,reservation, Reservation.class);
}
And the class Reservation in provider app:
package ma.ensias.agencevoyage.entities;
import java.io.Serializable;
import java.util.Collection;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.codehaus.jackson.annotate.JsonIgnore;
import org.codehaus.jackson.annotate.JsonIgnoreProperties;
import org.codehaus.jackson.annotate.JsonProperty;
#JsonIgnoreProperties(ignoreUnknown=true)
#Entity
#Table(name="reservations")
public class Reservation implements Serializable{
#Id
#GeneratedValue(strategy=GenerationType.IDENTITY)
private Long idReservation;
private String date;
#ManyToOne(cascade=CascadeType.ALL)
#JoinColumn(name="id_client")
private Client client;
#JsonIgnore
#ManyToMany(cascade=CascadeType.ALL)
#JoinTable(name="passager_reservation", joinColumns=#JoinColumn(name="id_reservation"), inverseJoinColumns=#JoinColumn(name="id_passager"))
private Collection<Passager> passagers;
#JsonIgnore
#ManyToMany(cascade=CascadeType.ALL)
#JoinTable(name="vol_reservation", joinColumns=#JoinColumn(name="id_reservation"), inverseJoinColumns=#JoinColumn(name="id_vol"))
private Collection<Vol> vols;
// Contructor without fields
public Reservation() {
super();
}
// contructor with date attribute
public Reservation(String date) {
super();
this.date = date;
}
// ----------------------- Getters and setters-------------------------------
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
public Client getClient() {
return client;
}
public void setClient(Client client) {
this.client = client;
}
public Collection<Passager> getPassagers() {
return passagers;
}
public void setPassagers(Collection<Passager> passagers) {
this.passagers = passagers;
}
public Collection<Vol> getVols() {
return vols;
}
public void setVols(Collection<Vol> vols) {
this.vols = vols;
}
}
and the controller is :
//-------------------Create a Reservation--------------------------------------------------------
#RequestMapping(value = "/ajouterReservation", method = RequestMethod.POST, consumes="application/json")
public ResponseEntity<String> ajouterReservation(#RequestBody Reservation reservation) {
metier.ajouterReservation(reservation);
return new ResponseEntity(HttpStatus.CREATED);
}
I also tested the provider using post man and it is working.
The error i'm getting is below :
GRAVE: Servlet.service() for servlet [appServlet] in context with path [/agencecentrale] threw exception [Request processing failed; nested exception is org.springframework.web.client.HttpClientErrorException: 415 Type de Support Non Supporté] with root cause
org.springframework.web.client.HttpClientErrorException: 415 Type de Support Non Supporté
at org.springframework.web.client.DefaultResponseErrorHandler.handleError(DefaultResponseErrorHandler.java:88)
at org.springframework.web.client.RestTemplate.handleResponseError(RestTemplate.java:532)
at org.springframework.web.client.RestTemplate.doExecute(RestTemplate.java:488)
at org.springframework.web.client.RestTemplate.execute(RestTemplate.java:446)
at org.springframework.web.client.RestTemplate.postForObject(RestTemplate.java:294)
at ma.ensias.agencecentrale.controllers.ReservationController.ajouterReservation(ReservationController.java:33)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.springframework.web.method.support.InvocableHandlerMethod.invoke(InvocableHandlerMethod.java:219)
at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:132)
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:104)
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandleMethod(RequestMappingHandlerAdapter.java:745)
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:686)
at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:80)
at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:925)
at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:856)
at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:936)
at org.springframework.web.servlet.FrameworkServlet.doPost(FrameworkServlet.java:838)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:650)
at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:812)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:731)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:303)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:218)
at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:122)
at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:505)
at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:169)
at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:103)
at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:958)
at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:116)
at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:452)
at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1087)
at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:637)
at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:316)
at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
at java.lang.Thread.run(Unknown Source)
Root cause : Problem is with content type set in the provider controller:
#RequestMapping(value = "/ajouterReservation", method = RequestMethod.POST, consumes="application/json")
public ResponseEntity<String> ajouterReservation(#RequestBody Reservation reservation)
Solution 1: remove consumes="application/json" in the handler method
Solution 2 : Set the headers accordingly before making the rest call and make use of exchange method of RestTemplate like below :
RestTemplate restTemplate = new RestTemplate();
HttpHeaders headers=new HttpHeaders();
headers.set("Content-Type", "application/json");
HttpEntity requestEntity=new HttpEntity(reservation, headers);
Reservation addedRes = restTemplate.exchange(REST_SERVICE_URI, HttpMethod.POST,requestEntity,Reservation.class);

Resources