Develop Reference

Use bean without #MongoEntity annotation in Quarkus Panache MongoDB

I have defined some beans to be stored in a Mongo Database. I am using Quarkus Panache MongoDB.
It works if I annotate the domain classes with #MongoEntity
#MongoEntity(collection="ThePerson")
public class Person {
public ObjectId id;
public String name;
...
}
I want to avoid the #MongoEntity in these classes, to put these clases in a separated package and not depend on the Panache, or even any quarkus dependency.
How can I configure these external beans?
Why? I want to share a package to help other teams that don't use quarkus but will use the same model.

What if you share an interface with all the getters for example? So you can easily share your interfaces in packages/libs.
With this approach, suppose you are going to expose your models over some REST apis returning Jsons for your clients, you can create a utility jar/package that automatically converts the Json for your pojos.
//your abstration
interface BasePerson {
ObjectId id();
String name();
...
}
//your model/entity
#MongoEntity(collection="ThePerson")
public class Person implements BasePerson {
public ObjectId id;
public String name;
...
}

Springboot JPA entity is auto loading lazy join entities

I have an entity as
#Getter
#Setter
#Entity
#Table(name = "feature")
#JsonIgnoreProperties({"hibernateLazyInitializer", "handler"})
public class Feature {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
#Column(name = "name")
private String name;
#Column(name = "description")
private String description;
#OneToMany(mappedBy = "featureId", fetch = FetchType.LAZY)
private transient Collection<FeatureComponent> components;
}
While in its Repository(Dao) file, I have
public interface FeatureDao extends JpaRepository<Feature, Integer> {
#Query("SELECT e FROM Feature e")
public List<Feature> getAll();
#Query("SELECT e FROM Feature e LEFT JOIN e.components fc WHERE e.id= :id")
public Feature getWithDetail(#Param("id") Integer id);
}
When I'm calling featureDao.getAll(); it returns all features but including components list filled and because of that, my response it being too large to load on client-side.
I'm unable to understand why it is happening when I'm using Lazy fetch mode and didn't mentioned joining with components in my getAll method.
Please help to resolve that issue,
Thanks in advance.

Just like #spOOm already mentioned I also suspect this is the side effect of Jackson Feature entity serialization into JSON triggering the load of all the components.
That is why using DTOs instead of plain Entities is usually advisable when returning data via a Controller. With DTOs, you clearly define whatever you want to include in the response to the caller. You can even reorganize your model so that it fits better the needs of the clients. You decouple your inner model and the model your API consumers know, making it possible to rework your inner model and still keep the same public model. You could have the following DTO.
public class FeatureSimpleDto {
private Integer id;
private String name;
private String description;
}
Then, in your Controller or Service (here you can find different opinions) you would basically convert your Feature entity into a FeatureSimpleDto that would be returned by your Controller. Here you can use mapping libraries such as MapStruct or you can do it on your own (I usually tend to prefer doing it on my own, one less dependency to rely on).

Using Lombok may be a problem, depending on the relationship between tables, try to create getters manually in entity classes.

Thanks to everyone for providing workarounds... But every work item requires lots of changes which were not possible for me...
Luckily I found a solution that is working fine for me... Better to post here...
Step-1: Add dependency in pom.xml file
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-hibernate5</artifactId>
</dependency>
Step-2: Add a 'Bean' for Hibernate Module
We can add bean in any file having #Configuration annotation... Even, we can add in Springboot main application file(where we have main method).
#Bean
public Module datatypeHibernateModule() {
return new Hibernate5Module();
}
That's it, Happy Coding...

Can we convert entity to dto/pojo object patially?

Is there any approach to convert entity to dto object partially? Or are there any best practices for using the entity, pojo/dto and response object in MVC pattern?

You have couple of approaches. I assume you have a web project.
Manual mapping approach. Create Dto map it manually to your entity. This would involve all the boilerplate code around it - Builders, all argument Constructor, getters, setters whatever approach you will use to populate the DTO.
The different hydration Technics apply in different situations. Builder pattern presumes you would have an immutable objects. Getters and Setters are supported out opf the box by frameworks as Jackson. You may decide to minimize your boilerplate code by using lombok, imutables or other frameworks.
Mapping framework. Another option would be to use a supplied mapper like ObjectMapper, or FastMap there may be other choices. This would remove large portion of manual mapping you would need to establish following aproach 1.
Deserializer. Example of such aproach would be spring-data-rest where your repository returns the entities straight which are than serialized in JSON . Using normal spring MVC this would be to return your entity straight to your controller layer and based on annotations or other means (serializers) map it to your network format JSON, XML whatever you use.
These are the different options. Which one is best depends on your usecase.

One of possible approaches is copy constructor. The example below.
// entity annotations ...
public class EntityExample {
private Long id;
private String name;
private Integer score;
// getters and setters ...
}
public class DtoExample {
private Long id;
pricate String name;
// For serialization and deserialization
public DtoExample() {
}
public DtoExample(EntityExample entity) {
this.id = entity.getId();
this.name = entity.getName();
}
// getters and setters ...
}

JPA 2.0 field annotation vs method annotation

in JPA 2.0 which is the difference between annotating a field and annotating a method (typically a getter)?
Example with field annotation
#Entity
public class MainEntity {
#Id
private Long id
#OneToMany
private RelatedEntity relatedEntity
//getters and setters and possible other methods
...
}
Example with method annotation
#Entity
public class MainEntity {
#Id
private Long id;
private RelatedEntity relatedEntity
//getters and setters and possible other methods
#OneToMany
public RelatedEntity getRelatedEntity(){
return relatedEntity
}
//other methods etc
...
}

With JPA you can use both methods to map the columns of your table in your entity class; fields/methods access doesn't change anything from a schema generation point of view nor in terms of translated queries. Generally speaking field annotation is cleaner (frameworks like Spring encourages it), methods annotation can grant you more flexibility (like with inheriting from an abstract entity class).
Please notice that in your second example there is an error:
#Entity
public class MainEntity {
private Long id;
private RelatedEntity relatedEntity
//getters and setters and possible other methods
#Id
public Long getId() {
return id;
}
#OneToMany
public RelatedEntity getRelatedEntity(){
return relatedEntity
}
//other methods etc
...
}

From user point of view there is no difference until it is consistent, but using annotation in different places change behavior of JPA provider (hibernate, EclipseLink, etc.).
Place where annotation were set gives JPA provider information about which access type you what to use. If you mix that setting annotations in both places then provider picks one and ignores rest. In example in your second listing hibernate will ignore #Id because you have #OneToMany on method and that means you prefer to use AccessType.PROPERTY.
Of course sometimes we don't want to use property access, because we have some extra methods that provides some logic and match to naming convention. Then we should use AccessType.FIELD.
In project you should use consistent style. Mixed style is valid, but you need to define #Access for almost all elements in your POJO.

Java annotation fields setter and getter how to

What I want to accomplish but don't understand really how it works its
#Table(name = "Categories")
public class Category extends Model {
#Column(name = "Name")
private String name;
}
With this code I want to annotation generate their respective setter and getter so I can use like
Category category = new Category();
category.setName("My Name");
category.save();
Whey I need setter and getter and not access/edit the value directly? Because some values has different treatment, like relations, and because I want to have fields that don't want to be edited. And I'm too lazy to do manually all the time this, with every model, also save a lot of work later to just put an annotation and set their field
My inspiration to try this was Android Annotations seems a solid and cool library, I know maybe its too advanced but my goal with this experiment its to have a library like that but focused on models like active record or another orm.
Tuts, tips, advices, books are welcome.
Regards
Edit 2013-10-25
My goal is to build a library capable to do this, because I'm too curious and want to learn how internally work, so I'll be able to power my framework with this feature, as jet just are small utilities but in the future I hope it save me a lot of work, you can see at github WSD Android

If you are too lazy to create the setters and getters of your variables why not just let your IDE generate it for you?
but if you do really insist, take a look at this plugin
This simply allows you to do this
#Table(name = "Categories")
public class Category extends Model {
#Setter
#Getter
#Column(name = "Name")
private String name;
}
WARNING.
the plugin is not well documented, you also need to configure your IDE to actually see it(eg category.getName())