Async EJB calls, Java Persistence API and XML. Carl Nettelblad

Transcription

1 Async EJB calls, Java Persistence API and XML Carl Nettelblad

2 Outline Asynchronous EJB calls Java Persistence API XML

3 Map realm roles to application roles Enable check box in Security configuration: Default Principal To Role Mapping (in Glassfish Admin console The admin console is one of those things you should disable fully in a production environment Or protect This options makes Glassfish group names map to security roles Otherwise you can specify a mapping yourself in the separate glassfish-web.xml

4 Databases Relational (SQL) databases Give persistence in a reliable and consistent way (transactionality) Different providers, accessed using JDBC drivers The need for connection pools for good performance Use parametrized queries in prepared statements For performance For avoiding SQL injection

5 Possible SQL injection String query = "INSERT INTO PERSON" + "(pnr, firstname, lastname, sex, age)" + "VALUES (1,'" + firstname + "','Svensson', 35)"; int rows = stmt.executeupdate(query);

6 Example, prepared statements PreparedStatement pstmt; pstmt = connection.preparestatement( "INSERT INTO PERSON (pnr,firstname,lastname,age) VALUES (?,?,?,?)"); pstmt.setint(1, 1); pstmt.setstring(2, "Nisse"); pstmt.setstring(3, "Nilsson"); pstmt.setint(4, 37); int x = pstmt.executeupdate();

7 tag for data tag for EJBs Simply annotate the servlet variables (private is OK) Only works for managed objects Objects created by the container, not by you

8 Transactions Making sure that it would seem like all operations occur in some specific order, not overlapping Serializability Not the same thing as seralization of objects This means that locks might need to be held even on data that was only read from tables, if you later write to another table Can cause low performance Deadlocks Think about what you read and where you put your transaction boundaries

9 Enterprise Java Beans Message beans Session beans Stateful State can be kept between different method calls from the same client Stateless No state between method calls Singleton Global instance

10 Interfaces Remote interface Parameters serialized Basically everything passed by value Lower performance Can be used in a distributed setting Local interface Only used within a single JVM instance Higher performance Pass by value or pass by reference as usual

11 A bit of history Old-style EJBs have fake interfaces mapped to bean class These days, declare the interfaces, tag them Inherit from them and tag your session bean

12 Additional annotation on Controls how the method or EJB participates in transactions Sometimes you want to opt out or have a separate transaction Declarative

13 Asynchronous EJB methods Imagine you want to get information on 100 users Request sent to a US server through an EJB 100 ms roundtrip at the very best ArrayList<User> users = new ArrayList(); for (String username : userlist) { } users.add(ourbean.getuser(username)); This will take ten seconds Not really needed The US server and your web server can both do much better

14 What to do? Move the US server here Change the API Send the full list of users Excellent idea, not always possible Concurrency Make many simultaneous requests Creating threads manually can be hard

15 The Java Future Standard interface for representing a value that does not necessarily exist yet in Java Used in Java concurrency API Methods cancel, get, iscancelled, isdone get will wait until the value is really available Exceptions can be passed at get time (wrapped in ExecutionException)

16 Asynchronous EJB methods Tag your method Change the return type from e.g. User to Future<User> Write normal, synchronous implementation Just change the return line from e.g. return usertoreturn; to Return new AsyncResult<User>(userToReturn);

17 What would the client look like? ArrayList<Future<User>> futures = new ArrayList(); for (String username : userlist) { futures.add(ourbean.getuserasync(username)); } ArrayList<User> users = new ArrayList(); for (Future<User> future : futures) { users.add(future.get()); }

18 What s the difference? We give the EJB a change to start processing all the requests we know that we will make Then, we start looking at the results Hiding latency The EJB asynchronous calls keep transactions and all other nice aspects of the container The only thing you need to do is to separate the call and get return value part in your client Futures very powerful general concept for concurrency and throughput

19 Object-relational mapping and JPA The object-oriented world and the relational world are similar, yet different Objects are separate entities Inheritance, references to other objects in many ways Easy to represent trees and other graphs Relational databases are based on tables All rows have the same structure Closely tied to the table Fixed relations between tables (Graphs through self-relations)

20 Objects and tables Different data types Quite common to create a Java Bean/ value object to represent the content of a table row Risk of writing lots of braindead CRUD code CReate Update Delete Separate methods for each bean class, mapping to each table High risk of manual errors

21 Another way What if we could say which fields in a class map to which columns in a table? And how references to other classes map to database relations Even create the database schema from our classes This is the foundation of object-relational mapping Java Persistence API is one way to do it

22 Two views on JPA Convenient way to model the database structure as Java classes Using Java as a tool to interact with the database Convenient way to persist Java objects permanently and with transaction safety Using the database as a tool for our application

23 Components in JPA An API A query language Metadata for the object/relational mapping Contains a service provider interface Different databases or other resources can provide this interface Your code can easily move Not necessarily easy to move existing data

24 Components in JPA Persistence providers Default provider in Java EE 6 Other providers do exist

25 How to map classes to tables? Same old story Annotations vs. XML One or the other Do you want to map the same Java classes to different database schemas? Go for XML Is the mapping fixed? Go for annotations

26 A POJO Java bean public class BankAccount { private String accountid; private String ownername; private double balance;... } The account ID is the primary key We want to store this data in our database

27 JPA entities Entities are the persistent data objects in our application Can be simply fields of primitive types Can be more complex Each entity has a well-defined identity, key that can be used to retrieve it (primary key in DB) Their state is exposed They are not remote-accessible Entities are supposed to live on beyond shutdown of the application

28 Example import java.io.serializable; import javax.persistence.entity; import public class Account implements Serializable { /** The account number is the primary key for the persistent object public int accountnumber; public String ownername; public int balance; /** * Entities must have a public no-arg constructor */ public Account() { // auto-generation accountnumber = (int) System.nanoTime(); }

29 Example public void deposit(int amont) { } balance += amount, } public int withdraw(int amount) { if (amount > balance) { return 0; else { balance -= amount; return amount; }

30 (Some) additional features If field names map to column names and class names map to table names, nothing else is if column name doesn t match field name Additional attributes to control mapping for fields that should not be created based on Annotating references to other objects and collections of for handling separate tables carrying relationship information (needed for many-to-many)

31 Schema generation Configuration will determine whether schema is autocreated Property javax.persistence.schema-generation.database.action with values none, create, drop-and-create, drop Dropping means removing everything Good for testing from a blank slate Dangerous anywhere close to production data

32 persistence.xml Configuration for the JPA services <?xml version="1.0" encoding="utf-8"?> <persistence xmlns=" <persistence-unit name="unit1"> <jta-data-source>mydb</jta-data-source> <non-jta-data-source>mydb-nontrans</jta-data-source> <properties> <property name="eclipselink.target-database" </properties> </persistence-unit> </persistence> value="javadb"/>

33 Explanation The data source With transaction management Without transaction management Specify SQL dialect Derby in this case

34 Entity manager Entry point for managing persistence Interaction with data source, transactions

35 Example methods Query for objects (find/query) Query on ID or query using EB-QL Update object based on state of constructed object New object persist Existing objects merge detach managed entities to become regular objects remove entities (from persistence) refresh entity based on current database state (as seen within transaction)

36 Stateless EJB example package examples.entity.intro; import java.util.list; import javax.ejb.stateless; import javax.ejb.remote; import javax.persistence.*; /** * Stateless session bean facade for account entities, * remotely public class BankBean implements Bank { /** * The entity manager object, injected by the container private EntityManager manager; public List<Account> listaccounts() { Query query = manager.createquery("select a FROM Account a"); return query.getresultlist(); }

37 Stateless EJB example public Account openaccount(string ownername) { Account account = new Account(); account.ownername = ownername; manager.persist(account); return account; } public int getbalance(int accountnumber) { Account account = manager.find( Account.class, accountnumber); } return account.balance; public void deposit(int accountnumber, int amount) { Account account = manager.find(account.class, accountnumber); account.deposit(amount); } } }

38 Stateless EJB example public int withdraw(int accountnumber, int amount) { Account account = manager.find(account.class, accountnumber); return account.withdraw(amount); } } public void close(int accountnumber) { Account account = manager.find(account.class, accountnumber); manager.remove(account); }

39 Conclusion JPA allows you to write code almost like you were just using Java objects Code focusing on intent You still need to have a design that maps to database concepts The Java EE framework will handle many aspects You can still run into unexpected failed transactions due to e.g. locking There are several implementations of JPA One is the Java ORM library Hibernate (which predates the JPA standard)

40 XML Hypertext Markup Language HTML is based on Standard Generalized Markup Language Standardized in the 1980s Very general language Angle-bracket tags just one concrete syntax of SGML Structure of markup languages can be defined using a document type declaration grammar

41 Flaws of SGML Way too general Hard to parse Tags allowed to be non-closed Grammar used actively, many things that could be deduced could therefore be omitted In all: A good way to allow many structured languages to be modeled in a standardized way Very hard to handle the standard

42 Enter HTML HTML is one specific SGML application Didn t use many of the features In fact, web browsers didn t support them Maybe we should make a better HTML, or a simpler SGML? Extensible markup language is born

43 Nature of XML Native UNICODE Semantics and syntax in UNICODE, many practical encodings possible Carried over from HTML/SGML Tags (elements) and attributes Text and/or other tags within tags Comments Whitespace non-significant Tags are case-sensitive Always end tags, so self-ending tags

44 CDATA Angle brackets and other special characters can be escaped, using entities < for <, > for > etc If we have a lot of binary data, we can instead use CDATA <![CDATA[ function matchwo(a,b) { if (a < b && a < 0) then { return 1; } else { return 0; } } ]]> Any data except for the characters ]]> can be used

45 Well-formed documents XML makes a distinction between processors and applications Most applications using XML are supposed to use a pre-existing processor (parser) to read the language A well-formed XML document should be OK to any processor Might not make sense to the application Follows the syntax rules Well-defined tree structure of elements Only a single root element in that tree Etc

46 Schemas Well-formedness is a matter of syntax It doesn t tell you whether the document makes sense Ideally, a document should specify what it is This is realized through schemas Two purposes: The schema describes the exact syntax A validating processor can parse the document according to that syntax The name/identifier of the schema can be used by an application to handle the file correctly Including versioning

47 Schema-less XML file <?xml version="1.0"?> <note> <to>tove</to> <from>jani</from> <heading>reminder</heading> <body>don't forget me this weekend!</body> </note> (Example from w3schools web site, sometimes good short references, but sometimes a bit too inaccurate.)

48 DTD Document type definition Schema definition carried over from SGML Usually put in a separate file <!ELEMENT note (to,from,heading,body)> <!ELEMENT to (#PCDATA)> <!ELEMENT from (#PCDATA)> <!ELEMENT heading (#PCDATA)> <!ELEMENT body (#PCDATA)>

49 With DTD reference <?xml version="1.0"?> <!DOCTYPE note SYSTEM " <note> <to>tove</to> <from>jani</from> <heading>reminder</heading> <body>don't forget me this weekend!</body> </note>

50 <?xml version="1.0"?> <!DOCTYPE note [ <!ELEMENT note (to,from,heading,body)> <!ELEMENT to (#PCDATA)> <!ELEMENT from (#PCDATA)> <!ELEMENT heading (#PCDATA)> <!ELEMENT body (#PCDATA)> ]> <note> <to>tove</to> <from>jani</from> <heading>reminder</heading> <body>don't forget me this weekend</body> </note> Inline DTD

51 !DOCTYPE PUBLIC <!DOCTYPE note SYSTEM " System means the schema is private We can also refer to standardized schemas using public DTD names If the processor knows about that name, it shouldn t fetch the actual DTD file from the specified location DTD names are on the form prefix//dtdowner//dtd-description//language Prefix can be ISO, + or ISO standard, approved other standard, unapproved other standard

52 HTML doctype HTML4 tried to be a good citizen DOCTYPEs like <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" " <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" " HTML5 simply says <!DOCTYPE html> Anything else is misleading, since HTML is not even trying to be valid SGML or XML anymore Hence no DTD for proper validation Browsers do care about the DOCTYPE

53 Why is it good to validate? The XML processor is supposed to be robust and tolerant to errors Tolerant as in not crash/behave unpredictably Difference to HTML attitude just accept anything Moving responsibility If the XML processor validates, your application does not have to check that every mandatory attribute or element does exist before reading it

54 Namespaces Different schemas and use cases might exist in the same document Two issues Point out uniquely what applications are referenced Bring this into the XML syntax Solution: Map namespaces to prefixes A prefix is the part coming before a colon in an element or attribute name

55 Namespace names Tend to be URLs Nothing is really found at those URLs, they are really just identifiers Arbitrary strings (without whitespace) The meaning is based on the meaning assumed by the using application Example: XHTML

56 Specifying prefixes A namespace is specified by assigning a prefix and then using that prefix The xmlns (XML namespace) prefix is predefined for this, xmlns:xhtml=" would mean the xhtml prefix is referring to the namespace Any element with the prefix is interpreted to be in that namespace Attributes are assumed to belong to their element But attribute namespace can also be specified Namespaces can be assigned on any element level

57 Default namespace Just specifying xmlns without a colon assigns the default namespace In a typical XML document, having this on the root element might be the only occurrence of xmlns in the full file Basically a type specification for the full file

58 W3C XML Schemas/XSD Beyond DTD, there are other ways to specify XML schemas One of the more common and well-supported are W3C XML Schemas, frequently stored in XSD files (XML Schema definitions) The schema usage is controlled by the specified namespaces in the file and extra attributes in the namespace

59 Note example again <?xml version="1.0"?> <note xmlns=" xmlns:xsi=" xsi:schemalocation=" note.xsd"> <to>tove</to> <from>jani</from> <heading>reminder</heading> <body>don't forget me this weekend!</body> </note>

60 schemalocation and nonamespaceschemalocation schemalocation is really a list of pairs: namespaces and the URIs to their schemas What if you want to map the default namespace? Just list its name What if you don t have a default namespace (a no namespace XML file)? Use the nonamespaceschemalocation attribute instead Only specifies a URI The corresponding schema must also actually be intended to be used without a namespace

61 XPath Find a subset of XML nodes using a path-like syntax <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE employee> <employee department="customer services"> <firstname> Eva </firstname> <lastname> Svensson </lastname> <age> 35 </age> </employee>

62 Navigate using XPath Refer to the Age element /employee/age Department attribute Additional conditions can be set, i.e. elements fulfilling customer service"]

63 XPath axes Default axis of child (next level) Axes can be specified explicitly child:: Other axes: ancestor/ancestor-or-self attribute child descendant/descendant-or-self (// for the node) following/following-sibling namespace parent (.. for the node) preceding/preceding-sibling self (. for the node)

64 XPath node tests Simply element names Can also be things like prefix:* for any element in a namespace or simply * for any element comment() text() XML nodes for text in tag bodies processing-instruction() - non-element tags such as <?xml node() any node

65 Predicates Additional constraint in brackets, boolean predicate Can also be an index to find a specific match (onebased) Normal operators +, -, *, div (for division), mod Comparison operators =,!=, <, >, <=, >= and, or, not() Union operator to match the union of two conditions Functions: contains, starts-with, concat, substring, normalize-space, count,

66 XML API in Java Streaming data: Simple API for XML org.xml.sax Event-driven, callbacks XML stream API javax.xml.stream Reading methods Reading full file: Document object model org.w3c.dom Object model Java XML Binding JAXB javax.xml.bind Mapping XML elements to Java objects

67 Document Object Model Read the full XML document Represent it as XML nodes Related to HTML DOM Parse tree HTML DOM models HTML logic as well Navigate through the tree getelementsbytagname getelementbyid Can be combined with XPath API

68 DOM example File fxmlfile = new File("D:/formdata.xml"); DocumentBuilderFactory dbfactory = DocumentBuilderFactory.newInstance(); DocumentBuilder dbuilder = dbfactory.newdocumentbuilder(); Document doc = null; try { doc = dbuilder.parse(fxmlfile); } catch (SAXException e) { // TODO Auto-generated catch block e.printstacktrace(); } catch (IOException e) { } // TODO Auto-generated catch block e.printstacktrace(); doc.getdocumentelement().normalize(); System.out.println("Root element :" + doc.getdocumentelement().getnodename()); NodeList nlist = doc.getelementsbytagname("subelement"); // using XPath instead NodeList nlist2 = (NodeList) xpath.compile("/subelement").evaluate(doc.getdocumentelement(), XPathConstants.NODESET);

69 DOM, pros and cons Pro Navigate freely in the full structure Cons Very verbose syntax Explicitly look up attributes, elements, inner text as separate nodes and look at them Not the best performance