Hibernate Import Wizard, Hibernate Entity-Editor,
Error-free Data-Type Mapping for all major Databases,
JPA-SQL enables you to write JPA Criteria Queries in SQL.
The powerful RapidClipse Hibernate-Tools simplify the entire database development process with JPA & Hibernate enormously
With the innovative Entity Editor, you can design your entire object / data model without coding. The Javacode with all needed Hibernate annotations is automatically generated correctly. Changes can be made in both wizard and code. Via Hibernate export, you can then generate your entire database. If you use an existing database, simply proceed in reverse order.
Entity Editor
Generated Javacode
@Entity
@DAO(daoClass = AutomakerDAO.class)
@Table(name = "Automaker")
public class Automaker {
private int id;
private String company;
public Automaker() {
super();
}
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id")
public int getId() {
return this.id;
}
public void setId(final int id) {
this.id = id;
}
@Column(name = "company")
public String getCompany() {
return this.company;
}
public void setCompany(final String noname) {
this.company = noname;
}
}
You can use database metadata import to generate the complete object model (entities and DAOs) that you need for database access with Hibernate. RapidClipse combines the Hibernate import with the graphical wizard from Dali JPA tools to improve importing considerably.
To crown it all, the database data types - even the proprietary - are then mapped with RapidClipse completely and correctly to appropriate Java types. This way you no longer need to bother with countless Hibernate annotations and manual code modifications.
If you formulate queries as SQL string, you have to accept many disadvantages, e.g. not type safe,
no refactoring or any other IDE support, non-debuggable, database-specific. However, alternative Java APIs are too
complicated for many developers.
With JPA-SQL you are now able to wirte your queries in SQL as you are used to. RapidClipse then generates Javacode
based on the JPA Criteria API automatically. Thus JPA-SQL combines the simplicity of SQL with the numerous advantages
of the powerful JPA Criteria API, e.g. type safe, fully IDE support, debuggable and database independence.
JPA-SQL Example:
findAllCustomer()
{
select * from Customer
}
Generated Java code:
public List<Customer> findAllCustomer() {
EntityManager entityManager = em();
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Customer> criteriaQuery = criteriaBuilder.createQuery(Customer.class);
Root<Customer> root = criteriaQuery.from(Customer.class);
TypedQuery<Customer> query = entityManager.createQuery(criteriaQuery);
return query.getResultList();
}
RapidClipse is powered by