![]() |
![]() |
Accueil > Intranet Michel Buffa > JavaEE6 Weblogic exercice 1
JavaEE6 Weblogic exercice 1De $1Table des matières
IntroductionIn this exercice we will write a JavaEE application that uses the new "web profile": a single project that can use JSF/JSP/Servlets/Web Services/EJBs/JPA with some limitations (no message driven beans, no timer, etc.) and one advantage: it is easier to manage as all components are located in a single project, and deployment is done in a single jar file. We will use a javaDB/Derby database for this application. Install the different components
Set Weblogic to deploy "exploded archives"Du to a weblogic 12c bug, project with the "web profile" raise some unexpected errors in the persistence context when the project properties are not set to "deploy as exploded archives" (see ) In the Java EE perspective, locate the server tab, right click on the weblogic server and choose "properties". In the dialog, go to weblogic/publishing and click on "publish as exploded archives".
Creating a "web profile JavaEE 6 project", write a servlet and an EJB for testingAdd a servlet, run the projectCreate a standard dynamic web project using Eclipse, call it for example "Exo1WebProfile". Click twice on the next button and in the last screen, check "Generate web.xml descriptor". Normally we do not need any XML settings in that file (JavaEE 6 replaced the need to XML settings by code annotations) but it will be useful to set the starting URL when we run the project in that file. Add a Servlet in the project, call it TestServlet, and add it in a package named "servlets". Click finish. Add some lines in the doGet() method, like these: protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { Then modify the web.xml file in order to start the project directly with this servlet. If you look at the Servlet code you will find an annotation that set the URL pattern for the servlet: @WebServlet("/TestServlet"), so let's modifiy the <welcome-file> entry in the web.xml descriptor: <welcome-file-list> Then right click the project, do Run As/Run on server. The first time you will be asked to choose a server. Select "weblogic 12c", check the checkbox so that thos will be a default value for this project and click finish. This should launch weblogic, the console tab should appear, etc. And after a while you should see a browser inside Eclipse showing "Welcome to Exo1 test servlet!". Add a stateless session bean EJBNow we will add a stateless session bean EJB to the project. Select as the type of element to add to the project "session bean (EJB 3.x)", add it in a package named "sessions" and name it "HelloWorldBean". Notice that in the wizard you have a select menu for stateless/stateful/singleton and below you may choose to implement some local or remote interfaces. For the moment leave everything with default values (stateless, no interface). Click finish. Add a method to this EJB. The code should look like this: package sessions; Notice the @Stateless and @LocalBean that indicates that we have a stateless session bean that can be only called from the same JVM. Remote session beans are not allowed in a web profile project. Call the session bean from the servletIn order to call the bean from the servlet, we need to add a few lines of code. Inject the EJB reference into the servlet: add these line below the class declaration: @EJB Fix the imports then add these lines in the doGet() method: out.println("The call to the HelloWorld EJB returned: " + bean.helloWorld()); Then run the project. If everything was ok, you should see a message : "The call to the HelloWorld EJB returned: hello world!". The @EJB annotation has injected a reference to an instance of the HelloWorld bean. You do not now if a "new" has been performed or if an existing instance has been used or if there are more than one instance running in the web server. Add JPA to the project, access a javaDB databaseCheck that Derby/JavaDB is running, connect the sample database to Eclipse and to WeblogicNormally you should have installed a Derby/JavaDB database to your system using informations from: Weblogic / Java EE6 FAQ and Guides. Check that you added the database both in Eclipse and in Weblogic. If you followed the instructions in Eclipse, in the java EE perspective, under the "Data Source Explorer" tab you should see the "sample" javaDB database, and be able to consult the data in the different tables:
And the data: Add JPA facet to the projectEclipse may help you a lot working with JPA but you need to add a JPA facet to the project. Right click on the project then properties/project facets and check the JPA facet. Validate. Look at your project, a persistence.xml file has been added under META-INF but there is also a new node in your project called "JPAcContent" that makes persistence.xml easier to access. This file is used for configuring the different persistence units that you will use in your project. A persistence unit is an object you will use from your code that works with a given database, using an Object Relational Mapping tool like Hibernate, Eclipse Link, Toplink, etc. This file also is useful for specifying if you are allowed to create tables, alter or delete tables, etc. Current persistence.xml file: <?xml version="1.0" encoding="UTF-8"?> As you may see it says that we are going to work woth eclipseLink (provider node...), that we are going to work with a local database (transaction-type), etc... these values are not sufficient for what we want to do. Configure the persistence.xml file using the design toolDouble click on the persistence.xml file, it shoud bring a designer. We are going to configure the database connection, so click on the connection tab at the bottom of the designer. We are using a remote database through a connection pool open on the we logic server. We will just need the JNDI name of the database. Change the Transaction type from "RESOURCE LOCAL" to "JTA" in the wizard, and enter the JNDI name of the sample database as it has been configured in WebLogic. If you followed the instructions from: Weblogic / Java EE6 FAQ and Guides it should be "sample". Ok, you are done with persistence.xml for the moment... Add a JPA entity class mapped to the Manufacturer table of the sample databaseLet's add an entity class generated from the Manufacturer table of the sample database... add a "jpa entity from table" to the project. If asked to what project you want to add the entity, select the current project. Click next. Then you are asked to choose the connection and table. Select the connection you added to Eclipse + select APP as a schema. The table will appear, then check MANUFACTURER Click twice next. Enter "entities" as the package name. On the last screen you may change the name of the class but it is better to leave the proposed name ("Manufacturer") unchanged. Click finished. Look at your project, under the "entities" package you should have a Manufacturer.java file that looks like this: @Entity The @Entity annotation says "I'm mapped to a table whose name of my name capitalized" (in that case, the MANUFACTURER table). The other annotation @Id says that the field is a primary key, and the @Column indicated the name of the column because default rules could not be applied here (defaut = name of the field in upper cases). Write a stateless session bean facade for this entity classUsually, one best practice consists in associating a "facade" with each entity class. A facade is a staless or stafull session bean that will provide CRUD operations on the associated model/entity, as well as convenience functions. Some IDEs like Netbeans or IDEA propose wizards that automate this process. Oracle Enterprise Pack for Eclipse proposes also such a wizard but only for oracle ADF projects ("Application Development Framework"). These are projects that use JSF and some special faces libraries from Oracle. They will not be studied during this training. So let's add a stateless session facade for Manufacturers to this project. Add a new stateless session bean, put it in the "sessions" package, name it ManufacturerFacade. Add in that bean an EntityManager so that we will be able to "talk" to the database and do other interesting things. Just add these two lines as class attributes: @PersistenceContext Add also a method that gets all the existing manufacturers from the table (the JPQL request is equivalent to a SQL select *...). Your session facade should look like that: package sessions;
Notice that executing this request does not return tuples but a Collection of Objects (in our case a List of instances of Manufacturer). Let's the servlet use the session bean facadeIn order to use our new EJB from the Servlet, simply inect it using the @EJB annotation, exactly like we did with the HelloWorldBean. Let's ass this on the Servlet, as well as a call to the getManufacturers() method. We will just display the resulting list by generating some HTML in the response: Here is the new code of the Servlet: package servlet; Run the project, it should display the list of all the manufacturers from the MANUFACTURER table of the sample database. Use a JSP with JSTL and EL to display the resultsIf you followed the training about Java EE Web Components or if you have some skills you should know that it is not a good practice to print HTML code in a servlet. We are going to use a JSP file for viewing the list of manufacturers while the servlet will act as a pure HTTP controller. This is called model 2 architecture (a form of MVC tailored for HTTP applications, see http://en.wikipedia.org/wiki/Model_2) . Servlet is a controller, JSP a view and EJBs are dedicated for business processing and data access. Modify the servlet so that the request if forwarded to a JSP for displaying the dataModify the servlet so that the HTTP request is passed to a JSP for finishing the treatment (generating the view). The trick consists in a adding to the request the data to be displayed before forwarding the request to the JSP: New version of the servlet : protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { Add a JSP page for viewing the data, using JSTL and ELAdd a JSP file in your project, name it "DisplayManufacturers.jsp" and replace the generated content by this one: <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> Notice the line: <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix ="c" %> That indicates that we are going to use the JSP Standard Tag Library (JSTL), all elements with the namespace c: will use the core part of the JSTL (if, then, else, forEach, etc). In order to display the manufacturers' properties we use the EL expression langage. For example, ${m.name} will call the getName() accessor of the bean Manufacturer.java, if there is no such method, we would get "EL property not found" errors. The line: <c:forEach var="m" items="${manufacturers}"> Defines a loop on a collection named "manufacturers". This collection will be searched in different scopes: the page, the request, the session, the context, etc. As in the servlet we put an attribute named "manufacturers" in the request, it is the one that will be found. More informations about JSTL and EL are available here: Implements the rest of the CRUD operationsWe will now add some methods to the facade in order to be able to create new manufacturers, remove an existing manufacturer or look for a manufacturer... Add several methods to the ManufacturerFacade.java fileIn that example we added some "classic" methodes for a facade. Look at them as we will modify the HTTP part of the application later on (Servlet, JSP) in order to exploit these new functionnalities... package sessions; And modify the Servlet so that it can do several actions depending on HTTP parametersWe modified the Servlet a little so that depending on a HTTP parameter called "action", the servlet can do different operations. In that example we only added "add" and "remove" operations. Look at the code and try to understand the logic of the operations... Copy and paste this code, run the project. package servlet; Then try this URL in your browser: http://localhost:7001/Exo1WebProfile/TestServlet?action=add&id=4&name=Buffa&phone=0662454545&email=buffa@unice.fr This will call the servlet with an action parameter equals to "add", indicating that we want to add a new manufacturer to the database. The rest of the parameters describe the manufacturer we want to add. Normally, this line should add one new Manufacturer and dipslay an updated list. Check using the Data Source Explorer tab that the data has been added in the table. Try also to remove the entry you just inserted: http://localhost:7001/Exo1WebProfile/TestServlet?action=remove&id=4 Here again, check in the database that the entry has really been removed. If you try to remove other manufacturers using their IDs, you may encounter some exceptions as some of the manufacturers primary keys have a relationships to some foreign keys in other tables. Typical error: "Internal Exception: java.sql.SQLIntegrityConstraintViolationException: DELETE sur la table 'MANUFACTURER' a entraîné la violation de la contrainte de clé externe 'FOREIGNKEY_MANUFACTURER_ID' pour la clé (19985678). L'instruction a été annulée. Error Code: -1".. Adapt the JSP so that you can remove, add or search a manufacturerLet's add a form at the beginning of the page, and a link for removing a manufacturer directly in the table. The add and remove and count have been implemented in the servlet but the Search by Name or Remove by name did not have been implemented. You may try this code, then complete the implementation. <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> Notice also that we did not use any kind of pagination here, whereas the method findByRange() exists in the facade. You may try to add pagination to your JSP/Servlet too. Play with CDI, add injectable beans to the project, use of CDI qualifiersWe propose here to the Context Dependency Injection feature of Java EE6 by creating some injectable beans for decorating the list of manufacturers. Enable CDI in your projectIn order to enable CDI in a project, you must add a beans.xml file to the WEB-INF directory of your project. This file can be empty, this will be enough for enabling CDI, but a more "standard" version is preferable, as we will add things to it later on... WEB-INF/beans.xml: <?xml version="1.0" encoding="UTF-8"?> If you get null pointers exceptions in your project, maybe you forgot to add this beans.xml file or you put it in a wrong place. Create an injectableBeans package, add a TextDecorator interfaceIn a package named "injectableBeans", add a new interface named TextDecorator that looks like that: package injectableBeans; The beans that will implement this method will all have a decorate() method that takes a String as input and returns the same String but "decorated", for example, in bold or in italic... Add a beans that implements the TextDecorator interface, names BoldMakerpackage injectableBeans; This bean is just a plain Java class. However, when one creates a java bean, it is the same as having the @Dependant annotation. Thi "default scope" means that the bean, when injected, is injected directly. For non-default " Inject the bean in the Servlet, test the projectIn the Servlet, inject the previous bean using the @Inject annotation. @Inject TextDecorator decorator; Then in the displayManufacturers() method, modify the code to decorate in bold the name of each manufacturer before sending the list to the JSP for display. private void displayManufacturers(HttpServletRequest request, Run the project, you should see that the names of each manufacturer is in bold in the table. Add a second injectable bean for decorating Strings in italicWrite a second bean similar to the BoldMaker. Call it ItalicMaker this time. This one, instead of wrapping the String parameter with <B></B> it wraps it with <I></I>. The code should look like that: package injectableBeans; Try to deploy the project. You should see an error like this one: Caused By: .... Ambiguous ... dependencies for type [TextDecorator] with qualifiers [@Default] at injection point... blah blah... The error message clearly explains that the TextDecorator interface has two implementations, both with the default set of qualifiers. The CDI runtime finds both the implementations equally capable for injection and gives an error message explaining the “ambiguous dependencies”. Lets resolve this by adding a qualifier on the implementations. We will add a qualifier to both of them while only one is needed for disambiguation (the one without qualifier has the @Default qualifier, by default) Create two qualifier annotations, qualify the beans, qualify the injectionQualifier are special annotations, there is no code really inside them, they are more "markers" or user friendly lable that will help us (and the CDI framework) identify different implementations of a same interface. Add these two classes that defines the @BOLD and @ITALIC qualifiers in the "qualifiers" package: BOLD.java package qualifiers; ITALIC.java package qualifiers; Then, we just add this qualifier to our implementations of the TextDecorator interface: BoldMaker.java package injectableBeans; ItalicMaker.java package injectableBeans; Now, we "qualified" the implementations. Let's use the qualifier also in the Servlet, in order to indicate which implementation we would like: TestServlet.java @Inject @BOLD or @Inject @ITALIC Run the project, try both possibilities... you see how it works ! Nice isn't it ? Using interceptorsThe Interceptors do what they say – they intercept on invocation and lifecycle events on an associated target class. They are used to implement things like logging and auditing. Add an interceptor binding type annotation to the project named @LoggingWe will create a new annotation named @Logging that we will just add before a class definition or before a method for intercepting and method invocations. This is similar to the annotations we created for the BOLD and ITALIC qualifiers, but there are some particularities. Add this class in a new package called "interceptors": package interceptors; This time, we did not define a qualifier but an "InterceptorBinding", as the meta annotation @InterceptorBinding shows. Meta annotations are annotations on annotations. Notice also that the @TARGET meta annotation indicates that this new @Logging annotation we are defining could only apply on METHODS and TYPES (classes). Add an interceptor that implements the @Logging annotation/interfaceWe are going now to implement (or bind) an interceptor by creating a POJO class that looks like that: package interceptors; Hmmm most of the code are println, so don't panic ! What can we notice:
Update the beans.xmlThe interceptors may be specified on the target class using the @Interceptors annotation which suffers from stronger coupling to the target class and not able to change the ordering globally. The recommended way to enable interceptors is by specifying them in the beans.xml file. Add these lines to beans.xml to declare the interceptor: <interceptors> <class>org.samples.LoggingInterceptor</class> </interceptors> Annotated the ManufacturerFacade for logging, run the projectWe are nearly done. In order to bind the interceptor to a java bean target class, add a @Logging annotation to the ManufacturerFacade class, just before the class definition (or you may try later on to add this annotation just before some methods). @Stateless Run the project, look at the console ! You should see things like that: BEFORE: public java.util.List sessions.ManufacturerFacade.getManufacturers() Well done ! You have now a beautiful looging service that works with annotations ! To go further, we recommend reading a good course/tutorial on java reflexivity API, like this one by Michel Buffa (in french: http://deptinfo.unice.fr/twiki/pub/M...minfo-0910.pdf) and look at the official section of the JavaEE6 tutorial by Oracle: http://docs.oracle.com/javaee/6/tuto...doc/gkeed.html An excellent quick overview of CDI goodies is proposed in this blog entry (in french): http://blog.xebia.fr/2012/02/01/java...bien-se-tenir/
Mots clés:
|
Powered by MindTouch Deki Open Source Edition v.8.08 |