We Keep Coding

Generating JPA entities from existing database vs Security

I need to migrate my application from JDBC programing model to use Hibernate. As part of this I would like to use the Annotation based configuration of hibernate. For this I want to generate JPA entities from database. I know how to do this(Using Eclipse Link), but How can I ensure the data is secured when I create JPA entities from my IDE(Eclipse)? Because Ecplise Link is a third party tool, Is there some extra configuration to prevent my database access.
Is there a way achieve this through coding?

You could generate the model from an empty database which contains the structure only and no data.

Auto Class Generators for RESTful services

What I have,
I have a DB schema with 10 tables and basic relationships (one to one, one to many ) between the tables.
What I need,
I need to create webservices to access this DB Data (Lets ignore the business logic layer as of now) with basic CRUD operations
What I know,
I know we have JPA to generate entities, and jackson to map between json and POJO classes.
Now is there a tool which takes the DB Schema as input and generates the RESTful service classes, JPA entities with jackson annotations
Note:
We can use Spring to achieve most of it. But I dont want to use Spring or any J2EE framework for various other reasons.

I think NetBeans is the Best and the easiest.
Just right click on your web project and click on new as the picture
and if you want to create restfull web services from entity classes
Just right click on your entity classes package and click on new
Getting Started with RESTful Web Services

Have you considered JBoss Forge?
It's a tool that allows you, amongst many other things, to generate JPA entities from table and generate REST services as well (I've personally tested the JPA entities generation only). It doesn't rely on any framework, only on Java EE standard such as JPA and JAX-RS.
After creating the new project you have to call
jpa-generate-entities-from-table
to generate the entities (JPA classes) and then
rest-generate-endpoints-from-entities
to generate the REST endpoints.

In your case I think the IDE which you are using or you have option to use that is very important.
For MyEclipse
If you have option to use MyEclipse then you can expose JPA Entities via REST Web Services very easily without installing any plugins. Here is the link
Exposing JPA Entities via REST Web Services
Texo
You can also go for Texo if you think that is suitable for you
or if you are using Oracle WebLogic Server 12c (12.1.2) or later then
Oracle® Fusion Middleware Solutions will be a good choice

What's MySQL's role in a JPA project?

I am confused about MySQL's role within a JPA project. For instance, if the project is being made in eclipse IDE, how can this be exported in MySQL? What's MySQL's role in this project? I have researched about this, but I still need some clarification.

JPA is a specification that describes how to save Java objects (called entities) in a database. MySQL is one of many databases a JPA provider can use. You'll specify the database connection at runtime (often in a properties file), and you can generally configure your provider for different databases.

What's MySQL's role in this project?
MySQL is the database: where the data is stored. That's what its role is.
You typically don't need to "export" anything to MySQL from your project. Rather, you set up the JPA configuration file with the backend database settings (database type, hostname, account name, logical database name, etc), and the JPA provider (for example Hibernate) takes care of creating the necessary tables and indexes in your backend database.

MySQL is database management system, meaning it let's you store and query the data in handy manner. Eclipse is devepolment enviroment that helps programmers to create software. JPA is a standard for ORM that let's you map data from the database on the objects (f.e. in Java). There is little connection between these 3.

MySQL, as your research should have told you, is a database (where you store data in a tabular form).
Java Persistence API is an API that handles the mapping between data in a tabular format and an objects as used in a Java program.
This process is know as Object Relational Mapping.
The database is typically created from a set of scripts, so there's not normally an export process, although some JPA implementations such as Hibernate have a pretty good go at creating the database for you based on the mappings to object model without the need for you to write any database scripts.

Where does JPA store its actual data entities?

Where does JPA store its actual tables? I am using JSP with JPA in NetBeans 7.3.1 on Tomcat and need to backup entire projects including data. Where is the data located? Thank you.

JPA is just an interface specification and doesn't actually "do" or "store" anything; all of that is taken care of by the JPA provider. Most providers (such as Hibernate and EclipseLink) will use a SQL database as the backend, but DataNucleus in particular supports a very large array of backends, including NoSQL databases like BigTable and S3 and regular documents such as spreadsheets.
In your case, you need to look through your application's configuration and find where the DataSource is configured; this is probably either embedded in the war in a .properties file or specified in the Tomcat configuration for the application and made available via JNDI.

What's the difference between JPA and Spring Data JPA?

I am a bit confused about the difference between Spring Data-JPA and JPA. I know about JPA that it is a specification for persisting the Java Objects to a relational database using popular ORM technology.
In other words, JPA provides interfaces and other ORM technologies, implements those interfaces known as JPA provider e.g Hibernate.
Now, what exactly is Spring Data JPA?
Is Spring Data JPA has added some more functionality (Interfaces) over JPA and still it is specified only or it is also a JPA provider?
I saw Spring Data JPA works around repositories (DAO layer: if I am not wrong). So, I mean, how it is different using 'Spring Data JPA + Hibernate' or only using 'Hibernate' directing?

I saw Spring, JPA works around repositories (DAO layer: if I am not wrong). So I mean how it is different using 'Spring JPA + Hibernate' or only using 'Hibernate' directly?
As you said, JPA is an specification while Hibernate is a particular implementation of that specification (these implementations are usually referred to as Providers). By using Hibernate you tie yourself to that provider restricting your freedom to switch to another option when required (for example, you want to use EclipseLink or ObjectDB instead because Hibernate has a bug that halts your development process).
Quoting Spring Data JPA's documentation:
Implementing a data access layer of an application has been cumbersome for quite a while. Too much boilerplate code had to be written. Domain classes were anemic and haven't been designed in a real object oriented or domain driven manner.
Using both of these technologies makes developers life a lot easier regarding rich domain model's persistence. Nevertheless the amount of boilerplate code to implement repositories, especially is still quite high. So the goal of the repository abstraction of Spring Data is to reduce the effort to implement data access layers for various persistence stores significantly.
To sum it up, it is on top of JPA adding another layer of abstraction, kind of defining a standard-based design to support Persistence Layer in a Spring context. Those defined interfaces (known to Spring) provide the services that the framework handles using JPA to serve the results. You define a repository in a way Spring can scan the project and find it:
<repositories base-package="com.acme.repositories" />
Thus, allowing you to use it in the context of a container or outside of it.
Now what exactly is Spring, JPA. Is Spring, JPA has added some more functionality (Interfaces) over JPA and still it is specified only or it is also a JPA provider?
Spring Data JPA provides a definition to implement repositories that are supported under the hood by referencing the JPA specification, using the provider you define.

The Java Persistence API, sometimes referred to as JPA, is a Java framework managing relational data in applications using the Java Platform, Standard Edition (JavaSE) and Java Platform, Enterprise Edition(JavaEE).
Persistence in this context covers three areas:
The API itself, defined in the javax.persistence package.
The Java Persistence Query Language (JPQL).
Object-Relational metadata.
Spring Data JPA is part of the umbrella Spring Data project that makes it easier to implement JPA based repositories.
Features:
Sophisticated support to build repositories based on Spring and JPA
Support for QueryDSL predicates and thus type-safe JPA queries
Transparent auditing of domain class
Pagination support, dynamic query execution, ability to integrate custom data access code
Validation of #Query annotated queries at bootstrap time
Support for XML based entity mapping
JavaConfig based repository configuration by introducing #EnableJpaRepositories

JPA
JPA is a specification that standardizes the way Java Objects are mapped to a relational database system. Being just a specification, JPA consists of a set of interfaces, like EntityManagerFactory, EntityManager, and annotations that help you map a Java entity object to a database table.
There are several JPA providers, like HIbernate, EclipseLink, or Open JPA which you can use.
Spring Data JPA
Spring Data JPA is a JPA data access abstraction. Just like JPA, Spring Data JPA cannot work without a JPA provider.
Spring Data JPA offers a solution to the DDD Repository pattern or the DAO (Data Acess Object) pattern. It can also generate JPA queries on your behalf through method name conventions.
Spring Data JPA can work with Hibernate, Eclipse Link, or any other JPA provider. A very interesting benefit of using Spring or Java EE is that you can control transaction boundaries declaratively using the #Transactional annotation.

Jpa is a specification of java.it is used to persist data between java obect and relational database.
Spring data jpa- it is same like jpa means we can describe in below way.
Spring Data Jpa is jpa data abstraction access which means it likes a jpa but it add some extra functionality, Without jpa we can not implement the spring data jpa.