I am using Spring and Hibernate for CRUD operation of product table.
I have got model product.java
product model is defined as below:
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
#Entity
#Table(name = "PRODUCT")
public class Product {
private long gtin;
private String brandname;
private String subbrandname;
private String functionalname;
#Id
#Column(name = "gtin",unique=true)
public long getGtin() {
return gtin;
}
public void setGtin(long gtin) {
this.gtin = gtin;
}
#Column(name = "brand_name")
public String getBrandName() {
return brandname;
}
#Column(name = "brand_name")
public void setBrandName(String brandname) {
this.brandname = brandname;
}
The question is that field and data type of table product could be changed as per user input. Therefore how can I make product model dynamic so that I don't need to change code of product model in future. The changes can be made based on user input from the forms.
Here, I am using programmatic configuration of hibernate sessionfactory.
Related
I'm coming back to you because I'm blocked.
I'm currently facing a MultipleBagFetchException, please find bellow my Entity Expense.
To resolve this mainly the solution can be to fetch Lazy and the mistake is disappearing but at this point, my endpoint findAll() is not working, because fetches should be EAGER for this endpoint being able to work.
In other words, on both side, I'm blocked.
Impossible for me to change List for Set as it's totally against "my business need".
If anyone is having any idea how can I fix this... :(
Thank you very much guys.
Rgds,
Erick
package net.erickcaron.mybudgetapi.models;
import lombok.*;
import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.FetchMode;
import org.hibernate.annotations.LazyCollection;
import org.hibernate.annotations.LazyCollectionOption;
import javax.persistence.*;
import java.math.BigDecimal;
#Getter
#Setter
#AllArgsConstructor
#NoArgsConstructor
#ToString
#Entity
#Table(name="expenses")
public class Expense {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
#Column(name="total_amount")
private BigDecimal totalAmount;
#Column(name="shared_amount")
private BigDecimal sharedAmount;
#Column(name="personal_amount")
private BigDecimal personalAmount;
#ManyToOne(fetch = FetchType.EAGER)
private Shop shop;
#ManyToOne(fetch = FetchType.EAGER)
private Currency currency;
}
package net.erickcaron.mybudgetapi.rest;
import net.erickcaron.mybudgetapi.exceptions.IncorrectResourceInputException;
import net.erickcaron.mybudgetapi.models.Expense;
import net.erickcaron.mybudgetapi.services.CurrencyService;
import net.erickcaron.mybudgetapi.services.ExpenseService;
import net.erickcaron.mybudgetapi.services.ShopService;
import net.erickcaron.mybudgetapi.utils.Checkings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import java.util.List;
#RestController
public class ExpenseController {
#Autowired
private ExpenseService expenseService;
#Autowired
private ShopService shopService;
#Autowired
private CurrencyService currencyService;
#PostMapping("shops/{shopId}/currencies/{currencyId}/expenses")
#ResponseStatus(code = HttpStatus.CREATED)
public Long create(#PathVariable("shopId") Long shopId, #PathVariable("currencyId") Long currencyId, #RequestBody Expense expense) {
Checkings.checkFoundShop(shopService.findById(shopId));
Checkings.checkFoundCurrency(currencyService.findById(currencyId));
checkExpenseCalculation(expense);
return expenseService.create(shopId, currencyId, expense);
}
#GetMapping("/expenses")
public List<Expense> findAll() {
return expenseService.findAll();
}
#GetMapping("/shops/{shopId}/expenses")
public List<Expense> findAllByShopId(#PathVariable("shopId") Long shopId) {
Checkings.checkFoundShop(shopService.findById(shopId));
return expenseService.findAllByShopId(shopId);
}
#GetMapping("/expenses/{id}")
public Expense findById(#PathVariable("id") Long id) {
Checkings.checkFoundExpense(expenseService.findById(id));
return expenseService.findById(id).get();
}
#DeleteMapping("/expenses/{id}")
#ResponseStatus(code = HttpStatus.OK)
public void delete(#PathVariable("id") Long id) {
Checkings.checkFoundExpense(expenseService.findById(id));
expenseService.delete(expenseService.findById(id).get());
}
#PutMapping("/shops/{shopId}/expenses/{id}")
#ResponseStatus(code = HttpStatus.OK)
public void update(#PathVariable("shopId") Long shopId, #PathVariable("id") Long id, #RequestBody Expense expense) {
Checkings.checkFoundExpense(expenseService.findById(id));
Checkings.checkFoundShop(shopService.findById(shopId));
checkExpenseCalculation(expense);
expenseService.update(id, expense);
}
#PatchMapping("/expenses/{id}")
#ResponseStatus(code = HttpStatus.OK)
public void partialUpdate(#PathVariable("id") Long id, #RequestBody Expense expense) {
Checkings.checkFoundExpense(expenseService.findById(id));
checkExpenseCalculation(expense);
Expense expenseToUpdate = expenseService.instancingExpense(expenseService.findById(id).get(), expense);
expenseService.update(id, expenseToUpdate);
}
private void checkExpenseCalculation(Expense expense) {
if (!expenseService.checkIfExpenseCalculationIsCorrect(expense)) {
throw new IncorrectResourceInputException();
}
}
}
Based on the Expense entity you posted, your Shop and/or Currency entities probably have List *-to-many associations that you try to fetch with FetchType.EAGER. Based on this root entity, all associations reachable through some kind of EAGER attribute are considered and it is an error if there is more than 1 List *-to-many association.
What you can do is simply switch to the more logical type Set which doesn't have that problem or use LAZY which you probably also should do. You can control fetching in a fine grained manner by using entity graphs or join fetch in HQL queries.
i'm not a professional in spring boot / hibernate jpa, so i apologize in advance.
I have 2 Entities, one called Document and the other called Bgo. Document is the parent table and Bgo the child. So my objective is to create the Document and after that, Bgo will receive it's id, for example:
When i create the first Document, it will have id_document = 1, so after that, the Bgo will have id_document = 1 as well.
I want to populate the child's id with the parent's id.
Here is the Parent Entity:
package com.testing.testing.models;
import java.io.Serializable;
import java.sql.Date;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
#Entity
#Table(name = "DOCUMENT")
public class Document implements Serializable {
private static final long serialVersionUID = 1L;
#Id
#GeneratedValue(strategy = GenerationType.AUTO)
private long id_document;
private int num_document;
private Date date;
#OneToOne(mappedBy = "document", cascade = CascadeType.ALL)
private Bgo bgo;
public Document() {
}
public Document(Bgo bgo) {
this.id_document = bgo.getId_document();
this.bgo = bgo;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public Bgo getBgo() {
return bgo;
}
public void setBgo(Bgo bgo) {
this.bgo = bgo;
}
public long getId_document() {
return id_document;
}
public void setId_document(long id_document) {
this.id_document = id_document;
}
public int getNum_document() {
return num_document;
}
public void setNum_document(int num_document) {
this.num_document = num_document;
}
}
And Child Entity:
package com.testing.testing.models;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
#Entity
#Table(name = "BGO")
public class Bgo implements Serializable {
private static final long serialVersionUID = 1L;
#Id
private long id_document;
private String name_bgo;
private int num_bgo;
#OneToOne
#PrimaryKeyJoinColumn(name = "id_document", referencedColumnName = "id_document")
private Document document;
public Bgo() {
}
public Bgo(Document document) {
this.id_document = document.getId_document();
this.document = document;
}
public long getId_document() {
return id_document;
}
public void setId_document(long id_document) {
this.id_document = id_document;
}
public String getName_bgo() {
return name_bgo;
}
public void setName_bgo(String name_bgo) {
this.name_bgo = name_bgo;
}
public int getNum_bgo() {
return num_bgo;
}
public void setNum_bgo(int num_bgo) {
this.num_bgo = num_bgo;
}
public Document getDocument() {
return document;
}
public void setDocument(Document document) {
this.document = document;
}
}
I used the term PrimaryKeyJoinColumn cause i want Bgo's id to be the Document's id, thats why i also used the same name "id_document". So Bgo's id will be Primary and Foreign at the same time (if it is wrong please tell me a better way to do it, knowledge is always welcoming)
I have also Document's Repository:
package com.testing.testing.repository;
import com.testing.testing.models.Document;
import org.springframework.data.jpa.repository.JpaRepository;
public interface DocumentRepository extends JpaRepository<Document, Long> {
}
And Bgo's:
package com.testing.testing.repository;
import com.testing.testing.models.Bgo;
import org.springframework.data.jpa.repository.JpaRepository;
public interface BgoRepository extends JpaRepository<Bgo, Long> {
}
Document's Controller:
package com.testing.testing.controllers;
import java.util.List;
import com.testing.testing.models.Document;
import com.testing.testing.repository.DocumentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
#RestController
#RequestMapping(value="/document")
public class DocumentController {
#Autowired
DocumentRepository documentRepository;
#GetMapping
public List<Document> listDocument() {
return documentRepository.findAll();
}
#PostMapping
public Document createDocument(#RequestBody Document document) {
return documentRepository.save(document);
}
}
Bgo's Controller:
package com.testing.testing.controllers;
import java.util.List;
import com.testing.testing.models.Bgo;
import com.testing.testing.repository.BgoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
#RestController
#RequestMapping(value="/bgo")
public class BgoController {
#Autowired
BgoRepository bgoRepository;
#GetMapping
public List<Bgo> listBgo() {
return bgoRepository.findAll();
}
}
So basically, the problem is this:
enter image description here
When i create a new Document and also the Bgo object, Bgo's id is 0, as you can see in the image, the object Bgo has the "id_document = 0 ", shouldn't it be id_document = 1 ?
And when i try to list Bgo, it still shows id_document = 0:
enter image description here
That's how i want the database to be:
enter image description here
As you can see, they are different tables. But Document has the primary key and is the parent, and Bgo is a child cause it is receiving Document's id. As you can see, Bgo's has the Document's id, it is primary and foreign at the same time, thats why i used PrimaryKeyJoinColumn. Both of them have the same id, Document's id equals Bgo's id. So whenever i create a Document and a Bgo at the same time, both of them should have the same id.
you might need to use the inheritance functionality comes with Spring instead. have a look at this:
https://www.baeldung.com/hibernate-inheritance
you can for instance use the #Inheritance(strategy = InheritanceType.SINGLE_TABLE)
on your parent table. and then you will annotate the child with just the #Entity
and then you will extend it as you normally do in a normal Inheritance scenario
so your parent class will look like so:
import java.sql.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.Table;
import javax.persistence.InheritanceType;
#Entity
#Table(name = "Document")
#Inheritance(strategy = InheritanceType.SINGLE_TABLE)
public class Document {
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column(name = "Id")
private Integer Id;
#Column(name = "num_document")
private int num_document;
#Column(name = "date")
private Date date;
public Document() {
}
public Document( int num_document, Date date) {
super();
this.num_document = num_document;
this.date = date;
}
}
and the child will look like so
import java.sql.Date;
import javax.persistence.Entity;
import javax.persistence.Table;
#Entity
#Table(name = "Bgo")
public class Bgo extends Document {
#Column(name = "name_bgo")
private String name_bgo;
#Column(name = "num_bgo")
private int num_bgo;
public Bgo(String name_bgo, int num_bgo) {
super();
this.name_bgo = name_bgo;
this.num_bgo = num_bgo;
}
public Bgo() {
super();
}
}
and you will have One JPARepository which looks like so;
import org.springframework.data.jpa.repository.JpaRepository;
public interface DocumentRepository extends JpaRepository<Document, Integer> {
}
the result of this code, will generate one table in your database with one extra column dtype which will identify the record to be either Bgo or any other type you might need to add in the future. this is the idea behind inheritance anyway
I hope this helped
Here are the three different inheritance strategy you have using spring
Single mapping is the default mapping
And it uses #inheritance(strategy = InheritanceType.SINGLE_TABLE) annotation to the parent class
In this strategy, the parent class is a table and all its children will be specified in a discriminator column in the parent table. The column called dtype and it contain the name of the entity as a value.
Table per the class strategy is similar to the superclass strategy but the superclass is also an entity you need to avoid this one if you want to make so many join queries
Joined table strategy is used the same as above. In this strategy, the subclasses and the superclass will all be tables in the database, but the subclasses will not inherit the filed of the superclass, it is useful if we want to apply data integrity and null constrains on some field
for more details look here
https://thorben-janssen.com/complete-guide-inheritance-strategies-jpa-hibernate/
choose which one will suit your case and then you can use the implementation I provided in the first answer and you only need to change the this annotation
#Inheritance(strategy = InheritanceType.SINGLE_TABLE)
What I want to do is to get the total count in each month. So I have come up
with these queries. I followed the documentation on Spring Boot JPA
repository using #Query. But when I run my app, it goes Application
Startup Failed. I dont know if my query is right.
Here is my #Query
#Query("SELECT MONTH(date_completed) FROM shipment WHERE YEAR(date_created)=?1 GROUP BY MONTH(date_completed)=?1")
public List<Shipment> findByDate_completed(String date);
#Query("SELECT COUNT(*) FROM shipment WHERE YEAR(date_created)=?1 GROUP BY MONTH(date_completed)=?1")
public List<Shipment> countByDate_completed(String date);
Shipment.java
package com.pahrsek.smartfleet.model;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import com.fasterxml.jackson.annotation.JsonIgnore;
/**
* Delivery of goods
* #author JRDomingo
*
*/
#Entity
#Table(name="shipment")
public class Shipment {
#Id
#GeneratedValue(strategy=GenerationType.AUTO)
public Long id;
#Column(name="booking_number",unique=true)
public String bookingNumber;
#Column(name="wb_number")
public String wbNumber;
#ManyToOne
#JoinColumn(name="vehicle_id", referencedColumnName="id")
public Vehicle vehicle;
#ManyToOne
#JoinColumn(name="customer_id", referencedColumnName="id")
public Customer customer;
public String origin;
public String depot;
#ManyToOne
#JoinColumn(name="vendor_id", referencedColumnName="id")
public Vendor vendor;
public String type;
#Column(name="commodity_type")
public String commodityType;
#Column(name="truck_type")
public String truckType;
#Enumerated(EnumType.STRING)
public Status status;
#Column(name="delivery_date")
public Date deliveryDate;
#Column(name="fuel_po")
public String fuelPo;
#Column(name="client_ref_no")
public String clientReferenceNumber;
public String remarks;
#ManyToOne
#JoinColumn(name="driver_id",referencedColumnName="id")
public Personnel driver;
#ManyToOne
#JoinColumn(name="helper1_id",referencedColumnName="id")
public Personnel helper1;
#ManyToOne
#JoinColumn(name="helper2_id",referencedColumnName="id")
public Personnel helper2;
public enum Status{
New, Dispatched, Delivered, Completed, Cancelled
}
/******
* ACTUAL DATES IMPLEMENTED
******/
#Column(name="date_created")
public Date dateCreated;
#Column(name="date_dispatched")
public Date dateDispatched;
#Column(name="date_completed")
public Date dateCompleted;
#Column(name="date_cancelled")
public Date dateCancelled;
#Column(name="date_received")
public Date dateReceived;
#Column(name="farthest_destination")
public String farthestDestination;
#Column(name="client_rate")
public Double clientRate;
#Column(name="is_sub_con")
public boolean isSubCon;
#Column(name="sub_con_rate")
public Double subConRate;
#Column(name="fuel")
public Double fuel;
#Column(name="fuel_amount")
public Double fuelAmount;
#Column(name="route_code")
public String routeCode;
#ManyToOne
#JsonIgnore
#JoinColumn(name="dispatched_odometer_id",referencedColumnName="id")
public RegularOdometerUsage dispatchedOdometer;
#ManyToOne
#JsonIgnore
#JoinColumn(name="delivered_odometer_id",referencedColumnName="id")
public RegularOdometerUsage deliveredOdometer;
#ManyToOne
#JsonIgnore
#JoinColumn(name="completed_odometer_id",referencedColumnName="id")
public RegularOdometerUsage completedOdometer;
/**
* index 0 = Driver , index 1 = Helper1, index 2 = Helper2
*/
#JsonIgnore
#OneToMany(mappedBy="shipment",targetEntity=PersonnelRate.class)
public List<PersonnelRate> personnelRates = new ArrayList<PersonnelRate>();
#JsonIgnore
#ManyToOne
#JoinColumn(name="company_id", referencedColumnName="id")
public Company company;
#JsonIgnore
#ManyToOne
#JoinColumn(name="prepared_user_id", referencedColumnName="id")
public User preparedBy;
#JsonIgnore
#ManyToOne
#JoinColumn(name="customer_invoice", referencedColumnName="id")
public CustomerInvoice customerInvoice;
#JsonIgnore
#ManyToOne
#JoinColumn(name="trucker_settlement", referencedColumnName="id")
public TruckerSettlement truckerSettlement;
}
What I want to achieve is to get the count of shipments with the status 'Completed' in each month based on the current year.
If you need to get a custom info from your db, for example, a month number and count of related records you cannot return a whole entity from the query method. You have to use a projection. For example:
public interface MonthAndCount {
Integer getMonth();
Long getCount();
}
#Query("select month(s.dateCompleted) as month, count(s.id) as count from Shipment s where year(s.dateCompleted) = ?1 group by month(s.dateCompleted)")
List<MonthAndCount> getMonthAndCount(int year);
Note: it's important to use aliases (as month or as count) here to make the framework know how to fill you projection.
Test:
#Test
public void getMonthAndCount() {
List<MonthAndCount> monthAndCount = repo.getMonthAndCount(2017);
assertThat(monthAndCount).hasSize(4);
monthAndCount.forEach(System.out::println);
}
Result:
{month=1, count=1}
{month=2, count=1}
{month=3, count=1}
{month=12, count=2}
If you do a select * operation in your hql query in that case hibernate can map your table data to your entity class but if you select custom fields by performing some operation those fields you need to create projection classes to map that data.
But if you do not want to create any class just to fetch data from query in that case you can use an Object[] instead of your entity class.
So your methods will simply look this
#Query("SELECT MONTH(date_completed), COUNT(*) FROM shipment WHERE YEAR(date_created)=?1 GROUP BY MONTH(date_completed)=?1")
public List<Object[]> findByDate_completed(String date);
First let's say we have two tables. One table is an Employee table with the following columns:
EMPLOYEE:
------------------------
emp_id (int, primary key)
emp_name (varchar(125))
emp_dept (foreign key)
emp_intro (text)
The other table is a Department table with the following columns:
DEPARTMENT:
-----------
dept_id (int, primary key)
dept_label (varchar(25))
Here is a sample of the table's values
DEPARTMENT:
------------------------
dept_id | dept_label
------------------------
1 | Sales
------------------------
2 | Technology
------------------------
3 | Finance
In order to return the employee's info with a status label, we need to either perform a JOIN:
SELECT e, d.dept_label FROM employees JOIN department d ON d.dept_id = e.emp_dept
or a multi-table select:
SELECT e.emp_id, e.emp_name, d.dept_label, e.emp_intro FROM employees e, department d WHERE e.emp_dept = d.dept_id
However, when using JPA/Hibernate, we need to create two classes:
Employee.java
package com.example.entities;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
#Entity
#Table(name = "employees")
public class Employee implements Serializable {
private static final long serialVersionUID = 1L;
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column(name = "emp_id")
private long emp_id;
#Column(name = "emp_name")
private String emp_name;
#Column(name = "emp_dept")
private Integer emp_dept;
#Column(name = "emp_intro")
private String emp_intro;
public long getEmp_id() {
return emp_id;
}
public void setEmp_id(long emp_id) {
this.emp_id = emp_id;
}
public String getEmp_name() {
return emp_name;
}
public void setEmp_name(String emp_name) {
this.emp_name = emp_name;
}
public Integer getEmp_dept() {
return emp_dept;
}
public void setEmp_dept(Integer emp_dept) {
this.emp_dept = emp_dept;
}
public String getEmp_intro() {
return emp_intro;
}
public void setEmp_intro(String emp_intro) {
this.emp_intro = emp_intro;
}
public static long getSerialversionuid() {
return serialVersionUID;
}
}
Department.java
package com.example.entities;
import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
#Entity
#Table(name = "departments")
public class Department implements Serializable {
private static final long serialVersionUID = 1L;
#Id
#GeneratedValue(strategy = GenerationType.IDENTITY)
#Column(name = "dept_id")
private long dept_id;
#Column(name = "dept_label")
private String dept_label;
public long getDept_id() {
return dept_id;
}
public void setDept_id(long dept_id) {
this.dept_id = dept_id;
}
public String getDept_label() {
return dept_label;
}
public void setDept_label(String dept_label) {
this.dept_label = dept_label;
}
public static long getSerialversionuid() {
return serialVersionUID;
}
}
Then, there is the repository (DAO):
EmployeeRepository
package com.example.repository;
import.java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import com.example.entities.Employee;
public interface EmployeeRepository extends JpaRepository<Employee, Long> {
#Query("select e, d.dept_label FROM Employee e JOIN Department d ON "
+ "d.dept_id = e.emp_id")
public List<Employee> return getEmployees();
}
and lastly, the Java controller that binds the classed query to an endpoint of the application:
EmployeeController.java
package com.example.controllers;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.example.entities.Department;
import com.example.entities.Employee;
import com.example.repository.EmployeeRepository;
#Controller
public class EmployeeController {
#Autowired
EmployeeRepository er;
#RequestMapping(value = "/getEmployees")
public #ResponseBody List<Employee> getEmployees() {
return er.getEmployees();
}
}
I have already tested this entire structure with only retrieving rows inside of the Employee table (i.e. #Query("SELECT e FROM Employee e") ) and everything returns as is.
MY MAIN ISSUE is how does one return a JOIN QUERY while the query is inside of a specific class (table), being Employee, if I require contents inside of Department?
I've already tried #JoinColumn annotations and that didn't work as well (perhaps I did it wrong).
Any ideas? Thanks.
You dont have to use raw joins to do that, just use proper relation mapping. Relation between Employee and Departament sounds like #ManyToOne or #ManyToMany.
You will be able to eg employee.getDepartament() or query by employee.departament.name=:name
http://www.objectdb.com/api/java/jpa/ManyToMany
You can even map bidirectional relations so you will be able to get deparament from employee, as well as all employees from given deparaments
PS. #JoinColumn is used to delare DB columnt used for joins it it is different then created by selected named strategies (usualy entityname_id). Actual relation mapping is done by declaring #OneToOne #OneToMany #ManyToMany and those can but doesn't have to be used with #JoinColumn. It is strict JPA question.
Here you have complete documentation of JPA 2.1 specification
It describes in details how to declare relations as well as #MappedSuperclass, inheritance strategies and all other usefull stuff.
Hello brothers and sisters,
I have a class that keeps userAuthInformatin with authuserid column,username column, and authusertoken column.
I want to insert uuid number in authusertoken column with every insert. I learned about Generated(GenerationTime.INSERT) but i don't know exact way to do this.
package entities;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.Generated;
import org.hibernate.annotations.GenerationTime;
#Entity
#Table(name = "authusers")
public class AuthUser {
#Id
#GeneratedValue
private int authuserid;
#Generated(GenerationTime.INSERT)
#Column(name = "authusertoken")
private long authusertoken;
#Column(name = "username")
private String username;
public int getAuthuserid() {
return authuserid;
}
public void setAuthuserid(int authuserid) {
this.authuserid = authuserid;
}
public long getAuthusertoken() {
return authusertoken;
}
public void setAuthusertoken(long authusertoken) {
this.authusertoken = authusertoken;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
}
You can simply use the UUID Java class and assign a value to this token field at object creation time:
#Column(name = "authusertoken", columnDefinition = "BINARY(16)")
private UUID authusertoken = UUID.randomUUID();
If the current associated row already has a value, when fetching the Entity, Hibernate will set it using Reflection and override the authusertoken with the row's column value.
If this is a new object, the authusertoken will get a default UUID when the object is instantiated.