![]() |
![]() |
Accueil > Intranet Michel Buffa > JavaEE6 Weblogic exercice 2
JavaEE6 Weblogic exercice 2De $1Table des matières
IntroductionThis time we will look at new features of Java EE6/JPA:
Create an EAR project, an EJB project and a Dynamic Web/JPA projectAn Enterprise Application project (EAR) is a "composite" project, a container that will hold several other projects and deploy all of them at once in a .ear archive. Typically, an EAR project will be attached with several other subprojects such as:
So, you should get 4 projects: DemoEAR, demoEJB, demoEJBClient and demoWeb. You can check that everything is ok by looking at the properties of the DemoEAR projec, then look at "Deployment Assembly", you should see that the 3 other projects are in the assembly. Experiment with Remote EJBsAdd a remote EJB to the EJB projectAdd a session bean stateless but this tome check the "remote interface" option, and indicate for the name of the bean " DemoSessionEJB" and for the remote interface you should see that the dialog proposes automatically DemoSessionEJBRemote. Add an hello world method to the bean, like we did at the beginning of exercice one, yesterday. The code should look like that: package sessions; Notice that the bean implements DemoSessionEJBRemote , and that this interface has been automatically added to the DemoEJBClient project. This "generated project" is useful for standalone clients, as we will see now... Add the helloWord() method to the remote interface, in the file DemoSessionEJBRemote.java, from the DemoEJBClient project. The code should look like that: package sessions; At this stage, save all and deploy the EAR project to weblogic using right click on the server in the server tab of the Java EE perspective, and use the add/remote menu. It is important to deploy this project as we will need the JNDI name of the EJB we created, and this JNDI name is available from the weblogic admin console. Look for the JNDI name of the EJB in Weblogic consoleYou can do that by looking at the weblogic admin console, on the left, click on "base_domain", then "servers", then in the main page click on the name of your server, then in the main window you should have something like "JNDI tree"... Click on that, a new tab opens in which you can explore the names objects on your server. In the small tree, click on "weblogic" then you will find your application and the EJBs deployed. The "liaison name" of the EJB is the JNDI name. It should look like this: " java:global.DemoEAR.DemoEJB.DemoSessionEJB!sessions.DemoSessionEJBRemote " We will use this JNDI identifier in the standalone client... Write a standalone client for this EJBA standalone client is just a Java project with a java class (with a main) that uses the remote EJB we created. The client project is just a Java project. Create a new project of type "Java project", name it "DemoEJBClientStandalone". You must add two things in the build path so that the client code can compile and run:
Then you should have such a source code for the standalone client: package client; import java.util.Hashtable;import javax.naming.Context; import javax.naming.InitialContext; import javax.naming.NamingException; import sessions.DemoSessionEJBRemote; public class StandAloneClient { private static String INITIAL_CONTEXT_NAME = "weblogic.jndi.WLInitialContextFactory"; private static String PROVIDER_URL = "t3://localhost:7001"; private static String JNDI_NAME = "java:global.DemoEAR.DemoEJB.DemoSessionEJB!sessions.DemoSessionEJBRemote"; public static void main(String[] args) throws Exception { Context ctx = getInitialContext(); DemoSessionEJBRemote helloEJB = (DemoSessionEJBRemote) ctx.lookup(JNDI_NAME); System.out.println(helloEJB.helloWorld()); } private static Context getInitialContext() throws NamingException { Hashtable env = new Hashtable(); env.put(Context.INITIAL_CONTEXT_FACTORY, INITIAL_CONTEXT_NAME); env.put(Context.PROVIDER_URL, PROVIDER_URL); return new InitialContext(env); } } These info come from the Weblogic documentation (name of INITIAL_CONTEXT_FACTORY, etc.) Redeploy the EAR project, just to be sure (right click on server, then "add and remove"). Run the standalone client project (as a "Java application"). Normally you should see in the console the "Hello World" message. As you saw, we could call the EJB from any external host, as long as we indicate the right URL for the weblogic server. Write a bank account management applicationThis time, we will write a real application. A small bank account manager. Create an empty MyBank database in javaDB (from Eclipse), connect it to WeblogicUsing the "Data Source Explorer" in Eclipse, use the "New" menu but this time to connect to a database named MyBank that does not exist. Put admin/admin as user/password, and check the "create database if needed" option. Once created Eclipse connects the database, that is, for the moment, empty. Connect this database to Weblogic 12c, follow the same procedure as we did in Exercice 1. If you do not remember, just look at the informations in this page: Weblogic / Java EE6 FAQ and Guides. In the EJB project, configure persistence.xml for working with MyBank databaseThis time, contrarily to Exo1, we are going to generate the tables from the source code of the entity beans. Furthermore, if we change the properties of any entity class in the project, the table schemas will be updated too...
In the DemoEJB Project, create an entity class for an AccountUse the New/JPA entity menu and add an empty entity class to the project. Put it in a package named "entities" and name it Account. A bank account has a few properties:
Remember: a property is defined by getters and setters, so do not forget to generate/write getters and setters for id, name, balance. This time we will use an auto-generated primary key: @Id The @GeneratedValue annotation indicates that the PK is auto-generated, using any method, you do not care (AUTO). Other possible values = SEQUENCE, ID, etc. see the JPA course. You may also add some convenience functions like add(int ammount) or remove(int ammont) methods that will add or remove money from the bank account. In the end the basic Account.java entity class should look like that: package entities; Add a AccountFacade session bean to a package named "sessions" to the DemoEJB projectCreate a stateless session bean. Implement some methods for the CRUD operations like we did yesterday with the ManufacturerFacade. It is not important to have all of them but at least a create(String name, int balance) method so that we can create new bank accounts and a getAllAccounts() that does a select *. This is very similar to yesterday's exercice. Add also a method for creating some test accounts so that we will be able to play with a populated database: public Account create(String name, int balance) { Account a = new Account(name, balance); // insert in database Add a singleton EJB that will populate the database at deployment time, when the project is runpackage entities; The @Singleton annotation guarantees that only one instance of that bean will be created. The @Startup annotation indicates that this instance must be created at startup (deployment time), and the @PostConstruct annotation indicates that the annotated method should be called right after the instance of the bean has been created. In other words, this is a best practice for doing some init stuff when you deploy the application. As we are using a "drop and create" stategy table, this means that each time we deploy the application the tables are destroyed and re-generated. In order to work with some data, using the bean above, the database is always populated with some test data. So, save and deploy the EAR project, after deployment go to the MyBank database in the Data Source Explorer tab, refresh the schemas, a new schemas named "Admin" appeared, with two tables in it: an ACCOUNT and a SEQUENCE table (for generating ids). Look at the data in the ACCOUNT table, the beatles should be there... Add a Servlet and a JSP to manage the Accounts like we did yesterday for the manufacturersYour turn to work ;-) In the servlet :
Add some functionalities: transfert money from one account to anotherAdd a transfert(int sourceId, int destinationId, int ammount) method to the facade, that will remove some money from the first account, and add it to the other. You may also add a form in the JSP for entering Ids of Accounts and the ammount. Use JPA relationshipsAdd a new entity class for describing operations on an accountNow, we are going to improve the design of our models. We are going to use an entity class for describing Operations that are done on a given by account. An operation can be an account creation, a deposit or a retrieval of money on an account. An operation has the following properties:
And of course, we wil define a 1-n relationship between the Accounts and the Operations. An account has a list of operations associated. Add a new entity class named Operations in the "entities" package The code should look like this: package entities; Note that we are using the java.util.Date type, not the java.sql.Date. Here we do not have anything to do with SQL. We are working with Java objects ! Add a relationship between Account and OperationAn Account may have a list of Operations associated. The list starts always with the creation of the account. We add new operations to the list when an account is created, when money is added or removed from the account. See how we modified the add() and remove() methods, as well as the constructor. We also added a getter and a setter for the new "operations" property of Account. Here is how we modify the Account entity class: package entities; Modify the JSP so that the "Actions" column proposes to remove the current account and to show details of operationsTry to modify the table that displays the list of accounts so that it look like this: INSERT SCREENSHOT WHen one click on the "Details of operations" link, we call the servlet that looks for the Account by id, and redirect to a second JSP page named DisplayOperations.jsp that receives the selected account in the request and display in a table like that the details of operations for this account: INSERT SCREENSHOT Advanced topics : sort operations by acending dates, use entity bean property validationsSorting a relation maye done in several different ways: Using the @OrderBy annotation, unfortunately it works only when the relation does not involve an association table, and it works only on integer elements Using the @OrderColumn annotation on the entity's properties. Does work only with numeric elements, not dates... Using encapsulation and sort the Collection using Collection.sort(...) like in this example: @Entity Using a JPQL request with an order by expression... Modify the AccountFacade so that it can also be called remotely, call it from the stand alone clientThis time we would like to call methods from the AccountFaceEJB, from a client. Add a remote interface to this EJB, add classes nessary to the client so that it can compile and run. Try to display for example the list of Accounts.
Mots clés:
|
Powered by MindTouch Deki Open Source Edition v.8.08 |