- \n
- Eclipse IDE for Enterprise Java Developers Version: 2019-03 (4.11.0)<\/li>\n
- Spring Tools 4 \u2013 for Spring Boot <\/li>\n
- SoapUI 5.5.0 <\/li>\n<\/ul>\n
Spring Tools 4 for Spring Boot is a set of plugins for Eclipse that support building and running Spring Boot applications. You can add Spring Tools 4 to your existing Eclipse installation by going to the Eclipse Marketplace and searching for \u201cSpring Tools 4\u201d.<\/p>\n
You can download SoapUI at https:\/\/www.soapui.org\/downloads\/<\/a>soapui.html<\/a>. <\/p>\n
2. JAX-WS Hibernate Example<\/h2>\n
In this example, we will build is a simple web service that returns a list of events for the specified artist. The service has one method;
getEventInfo<\/code>. The method executes a transaction against a database to retrieve the list of events. We will create the web service using bottom-up web service development.<\/p>\n2.1 Create the Spring Boot Project<\/h3>\n
Let\u2019s start by creating a Spring Boot project. In the New Project \u2013 Select a Wizard<\/em> dialog box, expand Spring Boot and select Spring Starter Project. Click \u201cNext\u201d.<\/p>\n
\n![\"JAX-WS](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2018\/07\/project_wizard-wm.jpg\")
Select a Wizard<\/figcaption><\/figure>\n<\/div>\n In the New Spring Starter Project<\/em> dialog box, enter a name for the project. Also, enter the group, artifact and package information. Accept all the other default values. Click \u201cNext\u201d. <\/p>\n
\n![\"JAX-WS](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/07\/spring-starter-wm.jpg\")
New Spring Starter Project<\/figcaption><\/figure>\n<\/div>\n In the New Spring Starter Project Dependencies<\/em> dialog box, select Spring Boot Version 2.1.6. Also, select the Spring Data JPA and H2 Database dependencies. Click \u201cFinish\u201d. <\/p>\n
\n![\"\"](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/07\/project-depend-wm.jpg\")
Spring Starter Project Dependencies<\/figcaption><\/figure>\n<\/div>\n The JPA dependency will add Spring Data JPA and Hibernate capabilities to the project. We will be using an H2 embedded in-memory database. <\/p>\n
2.2 Add JAX-WS Dependencies<\/h3>\n
We will use Apache CXF as our JAX-WS web service stack. Open the pom.xml<\/em> file and add the cxf-spring-boot-starter-jaxws<\/em> dependency just below the spring-boot-starter-data-jpa<\/em> dependency:<\/p>\n
pom.xml<\/em><\/span><\/p>\n
<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\"\n\txmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n\txsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n\t<modelVersion>4.0.0<\/modelVersion>\n\t<parent>\n\t\t<groupId>org.springframework.boot<\/groupId>\n\t\t<artifactId>spring-boot-starter-parent<\/artifactId>\n\t\t<version>2.1.6.RELEASE<\/version>\n\t\t<relativePath \/> <!-- lookup parent from repository -->\n\t<\/parent>\n\t<groupId>com.javacodegeeks.examples<\/groupId>\n\t<artifactId>jax-ws-hibernate<\/artifactId>\n\t<version>0.0.1-SNAPSHOT<\/version>\n\t<name>jax-ws-hibernate<\/name>\n\t<description>Example project for Spring Boot<\/description>\n\n\t<properties>\n\t\t<java.version>1.8<\/java.version>\n\t<\/properties>\n\n\t<dependencies>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.boot<\/groupId>\n\t\t\t<artifactId>spring-boot-starter-data-jpa<\/artifactId>\n\t\t<\/dependency>\n\n\t\t<dependency>\n\t\t\t<groupId>org.apache.cxf<\/groupId>\n\t\t\t<artifactId>cxf-spring-boot-starter-jaxws<\/artifactId>\n\t\t\t<version>3.2.7<\/version>\n\t\t<\/dependency>\n\n\n\t\t<dependency>\n\t\t\t<groupId>com.h2database<\/groupId>\n\t\t\t<artifactId>h2<\/artifactId>\n\t\t\t<scope>runtime<\/scope>\n\t\t<\/dependency>\n\t\t<dependency>\n\t\t\t<groupId>org.springframework.boot<\/groupId>\n\t\t\t<artifactId>spring-boot-starter-test<\/artifactId>\n\t\t\t<scope>test<\/scope>\n\t\t<\/dependency>\n\t<\/dependencies>\n\n\t<build>\n\t\t<plugins>\n\t\t\t<plugin>\n\t\t\t\t<groupId>org.springframework.boot<\/groupId>\n\t\t\t\t<artifactId>spring-boot-maven-plugin<\/artifactId>\n\t\t\t<\/plugin>\n\t\t<\/plugins>\n\t<\/build>\n\n<\/project>\n\n<\/pre>\n
2.3 Create the JPA Entity Model <\/h3>\n
There are two entities in the entity model; Artist and Event. The Artist entity has an id<\/em> and a name<\/em> property. The Event entity has an id<\/em>, a venue<\/em>, and a date<\/em> property. The Artist entity has a one-to-many relationship with the Event entity, as illustrated in the Entity Relationship diagram below.<\/p>\n
![\"\"](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/07\/1-to-many-wm-1.jpg\")
One-to-Many Relationship<\/figcaption><\/figure>\n The diagram above shows that the Artist entity is associated to zero or more Event entities.<\/p>\n
2.3.1 Create the Artist Entity Class<\/h4>\n
Create a package
com.javacodegeeks.examples.entities<\/code> and a classArtist<\/code> with the following code:<\/p>\nArtist.java<\/em><\/span><\/p>\n
package com.javacodegeeks.examples.entities;\n\nimport java.util.ArrayList;\nimport java.util.List;\n\nimport javax.persistence.CascadeType;\nimport javax.persistence.Column;\nimport javax.persistence.Entity;\nimport javax.persistence.GeneratedValue;\nimport javax.persistence.Id;\nimport javax.persistence.OneToMany;\n\n@Entity\npublic class Artist {\n\n\t@Id\n\t@GeneratedValue\n\tprivate int id;\n\t\n\t@Column(unique = true, nullable = false)\n\tprivate String name;\n\t\n\t@OneToMany(mappedBy=\"artist\",\n\t\t\t cascade= {CascadeType.PERSIST, CascadeType.MERGE,\n\t\t\t\t\t\t CascadeType.DETACH, CascadeType.REFRESH})\n\tprivate List<Event> events;\n\t\n\tpublic Artist() {}\n\n\t\n\tpublic Artist(String name) {\n\t\tthis.name = name;\n\t}\n\n\n\tpublic int getId() {\n\t\treturn id;\n\t}\n\n\n\tpublic void setId(int id) {\n\t\tthis.id = id;\n\t}\n\n\n\tpublic String getName() {\n\t\treturn name;\n\t}\n\n\n\tpublic void setName(String name) {\n\t\tthis.name = name;\n\t}\n\n\n\tpublic List<Event> getEvents() {\n\t\treturn events;\n\t}\n\n\n\tpublic void setEvents(List<Event> events) {\n\t\tthis.events = events;\n\t}\n\n\n\tpublic void add(Event event) {\n\t\t\n\t\tif (events == null) {\n\t\t\tevents = new ArrayList<>();\n\t\t}\n\t\t\n\t\tevents.add(event);\n\t}\n}\n\n<\/pre>\nNote<\/strong>: You have will several errors at this point. They will be resolved in the next section of this example.<\/em><\/p>\n
There are several JPA annotations used in the Artist class. These annotations define the mapping between the entity model object and the database table and its columns. (Note that these annotations are from the
javax.persistence package<\/code>.)<\/p>\n- \n
- @Entity<\/em><\/strong> \u2013 This class-level annotation informs the JPA provider (Hibernate in our example) that this Java class should be persisted to a database table.<\/li>\n
- @Id<\/em><\/strong> \u2013 This field-level annotation designates the primary key of the entity and maps it to the primary key of the table. <\/li>\n
- @GeneratedValue<\/em><\/strong> \u2013 This annotation specifies how the primary key ID will be generated. In our example, we chose GenerationType<\/em>.AUTO,<\/em> <\/em><\/strong>meaning that the JPA provider (Hibernate) will decide which strategy to employ based on the database dialect used. (The H2Dialect is used in this example.) <\/li>\n
- @Column<\/em><\/strong> \u2013 This field-level annotation is used to assign specific attributes to a property. We are specifying that the name <\/em>property must be unique and that it cannot be null.<\/li>\n
- @OneToMany<\/em><\/strong> \u2013 This field-level annotation declares a one-to-many relationship between the Artist entity and Event entity. This annotation is placed on the
List<Event> events <\/code>property since there can be many Event entities associated with this one Artist. The mappedBy<\/em> attribute references the property on the \u201cmany\u201d side of the relationship; the Event entity. (We will create the Event entity in the next section.) The cascade attribute identifies which entity lifecycle events (if any) should be propagated to the target of the association. For example, CascadeType<\/em>.PERSIST<\/em> states that any events in the list should be persisted into the persistence context when the Artist is persisted.<\/li>\n<\/ul>\nThere are two constructors defined for the Artist class. The
Artist(String name)<\/code> constructor is used for convenience. Consequently, we must explicitly define a no-argument constructorArtist()<\/code>, which is required by the JPA Entity Manager.<\/div> <\/div><\/p>\nWe also added a helper method
add(Event event)<\/code>. The method will add the Artist to the Event entity when an event is added. This will set up the bi-directional link between Artist and Event.<\/p>\nAt this point, you will see the following error: Event cannot be resolved to a type<\/em>. Let\u2019s fix that.<\/p>\n
2.3.2 Create the Event Entity Class<\/h4>\n
Hover your cursor over
Event <\/code>and select Create Class \u2018Event\u2019<\/em>. Click the “Finish” button in the New – Java Class <\/em>dialog box and add the following code to the Event class:<\/p>\nEvent.java<\/em><\/span><\/p>\n
package com.javacodegeeks.examples.entities;\n\nimport javax.persistence.CascadeType;\nimport javax.persistence.Entity;\nimport javax.persistence.GeneratedValue;\nimport javax.persistence.Id;\nimport javax.persistence.JoinColumn;\nimport javax.persistence.ManyToOne;\n\n@Entity\npublic class Event {\n\n\t@Id\n\t@GeneratedValue\n\tprivate int id;\n\t\n\tprivate String venue;\n\t\n\tprivate String date;\n\t\n\t@ManyToOne(cascade= {CascadeType.PERSIST, CascadeType.MERGE,\n\t\t\t CascadeType.DETACH, CascadeType.REFRESH})\n\t@JoinColumn(name=\"artist_id\")\n\tprivate Artist artist;\n\t\n\tpublic Event() {}\n\n\tpublic Event(String venue, String date, Artist artist) {\n\t\tthis.venue = venue;\n\t\tthis.date = date;\n\t\tthis.artist = artist;\n\t}\n\n\tpublic int getId() {\n\t\treturn id;\n\t}\n\n\tpublic void setId(int id) {\n\t\tthis.id = id;\n\t}\n\n\tpublic String getVenue() {\n\t\treturn venue;\n\t}\n\n\tpublic void setVenue(String venue) {\n\t\tthis.venue = venue;\n\t}\n\n\tpublic String getDate() {\n\t\treturn date;\n\t}\n\n\tpublic void setDate(String date) {\n\t\tthis.date = date;\n\t}\n\n\tpublic Artist getArtist() {\n\t\treturn artist;\n\t}\n\n\tpublic void setArtist(Artist artist) {\n\t\tthis.artist = artist;\n\t}\n\t\n}\n\n<\/pre>\nThe Event class is also decorated with the
@Entity<\/code> annotation. It has anid <\/code>property for its primary key and two string properties for the venue name and the event date. It also has anArtist <\/code>property.<\/p>\nThe
@ManyToOne<\/code> field-level annotation specifies the relationship between the Event entity and the Artist entity. It is placed on theArtist artist<\/code> property as there can be many Events to one Artist.<\/p>\nThe
@JoinColumn<\/code> annotation specifies the column name in the Event table that will used to associate the Event to the Artist. (This will become the foreign key to the Artist table.)<\/p>\n2.4 Create the Data Loader Class<\/h3>\n
We can use Hibernate to create some sample data at startup. Create a package
com.javacodegeeks.examples.bootstrap<\/code> and classDataLoader<\/code> that implementsApplicationListener<ContextRefreshedEvent><\/code> : <\/p>\nDataLoader.java<\/em><\/span><\/p>\n
package com.javacodegeeks.examples.bootstrap;\n\nimport javax.persistence.EntityManager;\nimport javax.persistence.EntityManagerFactory;\n\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.context.ApplicationListener;\nimport org.springframework.context.event.ContextRefreshedEvent;\nimport org.springframework.stereotype.Component;\n\nimport com.javacodegeeks.examples.entities.Artist;\nimport com.javacodegeeks.examples.entities.Event;\n\n@Component\npublic class DataLoader implements ApplicationListener<ContextRefreshedEvent> {\n\n\t@Autowired\n\tprivate EntityManagerFactory entityManagerFactory;\n\n\t@Override\n\tpublic void onApplicationEvent(ContextRefreshedEvent event) {\n\t\tEntityManager entityManager = entityManagerFactory.createEntityManager();\n\t\t\n\t\tentityManager.getTransaction().begin();\n\t\t\n\t\tArtist artist = new Artist(\"The Who\");\n\t\t\n\t\tEvent Event1 = new Event(\"Wembley Stadium\", \"July 6, 2019\", artist);\n\t\tEvent Event2 = new Event(\"Hollywood Bowl\", \"October 28, 2019\", artist);\n\t\t\n\t\tartist.add(Event1);\n\t\tartist.add(Event2);\n\n\t\tentityManager.persist(artist);\n\n\t\tentityManager.getTransaction().commit();\n\t\t\n\t\n\t\tentityManager.getTransaction().begin();\n\t\t\n\t\tArtist artist2 = new Artist(\"The Rolling Stones\");\n\t\t\n\t\tEvent Event3 = new Event(\"Madison Square Garden\", \"September 12, 2019\", artist2);\t\t\n\t\tEvent Event4 = new Event(\"Dodger Stadium\", \"November 25, 2019\", artist2);\n\t\t\n\t\tartist2.add(Event3);\n\t\tartist2.add(Event4);\n\t\t\n\t\tentityManager.persist(artist2);\n\t\t\n\t\tentityManager.getTransaction().commit();\n\t}\n\n}\n\n<\/pre>\nThe
EntityManagerFactory <\/code>(used to create anEntityManager<\/code>) is injected into the class using the@Autowired<\/code> annotation. AnEntityManager <\/code>is used to create and delete entity instances and to find entities by their primary keys. It can also be used create and run queries. If theEntityManager <\/code>is managed by the application, (as is the case here), it is also used to manage the lifecycle of entity instances through transaction management. <\/p>\nThe
DataLoader <\/code>class listens for theContextRefreshedEvent<\/code> that gets raised when theApplicationContext<\/code> is initialized or refreshed. It implements theonApplicationEvent<\/code> method, which adds a couple of artists and their associated events to persistence context. Notice that theEntityManager <\/code>is used to start and commit the transactions. Also notice that we only need to persist theArtist <\/code>instance. The Event instances will be persisted automatically, thanks to CascadeType<\/em>.PERSIST<\/em> directive and our helper method.<\/p>\n - @Id<\/em><\/strong> \u2013 This field-level annotation designates the primary key of the entity and maps it to the primary key of the table. <\/li>\n
- @Entity<\/em><\/strong> \u2013 This class-level annotation informs the JPA provider (Hibernate in our example) that this Java class should be persisted to a database table.<\/li>\n
![\"\"](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/07\/h2-wm.jpg\")
![\"\"](\"https:\/\/examples.javacodegeeks.com\/wp-content\/uploads\/2019\/07\/h2-select-wm.jpg\")