RapidClipse / Hibernate Tools

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

Error-free Hibernate import and generating entity-classes
Error-free data type mapping for all major databses
JPA-SQL query editor - Write SQL, get JPA Criteria code
Fully automated transaction and entity lifecycle management without the need of using Java EE

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();
}

Learn more

RapidClipse is powered by

Hibernate Tools

Greatly Optimized

Database Design fascinating easily

Import Wizard for using already existing Databases

Error-free Data-Type Mapping for all major Databases

JPA-SQL