Java EE 6 Cookbook for Securing, Tuning, and Extending Enterprise Applications

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

Java EE 6 Cookbook for

Securing, Tuning, and Extending Enterprise Applications

Book Description
Secure your Java applications using Java EE built-in features as well as the well-known Spring Security framework. Utilize related recipes for testing various Java EE technologies including JPA, EJB, JSF, and Web services. Explore various ways to extend a Java EE environment with the use of additional dynamic languages as well as frameworks. A learn-by-example based approach that focuses on key concepts to provide the foundation to solve real world problems.

Book Details

• Publisher:        Packt Publishing
• By:        Mick Knutson
• ISBN:        978-1-8496-8316-6
• Year:        2012
• Pages:        356
• Language:        English
• File size:        29.2 MB
• File format:        PDF
• Download:        

  本帖隐藏的内容

  Java EE 6 Cookbook for Securing, Tuning, and Extending Enterprise Applications.rar (11.36 MB, 需要: 20 个论坛币) 本附件包括：

  • Java EE 6 Cookbook for Securing, Tuning, and Extending Enterprise Applications.pdf

  2015-4-25 19:51:31 上传

  
  需要: 20 个论坛币  [购买]
  
  
  

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Applications Application Enterprise Extending Cookbook additional framework including concepts features

1. Getting ready
   
2. 
   
3. In order to use the @CollectionTable annotation, you first need to understand why they have been added to the JPA specification. While I feel this is a powerful new feature, it is important not to overuse this feature for mapping.
   
4. 
   
5. How to do it...
   
6. 
   
7. The @CollectionTable annotation can be added to a Collection<T> or a Map<K, V> entity attribute. This allows for some interesting mappings to store related entities.
   
8. 
   
9. In the case of a Collection<V>, you can choose a String or Integer as your collection element such as Collection<String>. You might also choose to have a custom collection of Objects such as List<Phone>. You might even find a usage for implementing a Map<K, V> Collection table. In these cases, you will still use a String or Integer as a key, and a custom object as your value such as Map<String, Address> to define your custom mapping:
   
10. 
    
11. To start with a simple example, we can start by mapping a collection of Strings to our Entity:
    
12. @ElementCollection
    
13. @CollectionTable(name = Constants.HOBBIES,
    
14. joinColumns = @JoinColumn(name = Constants.CUSTOMER_ID))
    
15. @Column(name = Constants.HOBBY_NAME, nullable = true)
    
16. private Collection<String> hobbies = new HashSet<String>();
    
17. We need to annotate this collection with @ElementCollection to denote that this is a basic attribute type, and that it is not acting as a container. We then define @CollectTable annotation where we can specify the table name used for the hobbies and the respective joinColumn, or foreignKey referring back to our customer. When we generate a <dataset> for testing this mapping, we end up with the following code:
    
18. <CUSTOMER id='103' USERNAME="user3"
    
19. FIRSTNAME="Foo" LASTNAME="UserTwo"/>
    
20. <HOBBIES CUST_ID="102" HOBBY_NAME="BASE-Jumping"/>
    
21. The same mapping will work when trying to map a collection of custom objects such as List<Phone>. Our @JoinColumn still allows JPA to map the Phone back to the Customer to whom this phone belongs. When we generate a <dataset> for testing this mapping, we end up with the following code:
    
22. <CUSTOMER id='103' USERNAME="user3"
    
23. FIRSTNAME="Foo" LASTNAME="UserTwo"/>
    
24. <HOBBIES CUST_ID="102" HOBBY_NAME="BASE-Jumping"/>
    
25. <PHONES AREACODE="415" PHONE_NUMBER="5551212"
    
26. TYPE="WORK" CUST_ID="102"/>
    
27. When we start getting a little more complex by mapping a Map<K,V> into our Entity, we need to be more specific on how JPA will map our custom object.
    
28. In this case, we still define our @ElementCollection, and our @CollectionTable just as mapping a collection, List, or Set:
    
29. 
    
30. @ElementCollection
    
31. @CollectionTable(name = Constants.CUSTOMER_ADDRESSES,
    
32. joinColumns = @JoinColumn(name =
    
33. Constants.CUSTOMER_ID))
    
34. @MapKeyColumn(name = Constants.ADDRESS_KEY)
    
35. private Map<String, Address> addresses =
    
36. new HashMap<String, Address>();
    
37. We now add an additional annotation, @MapKeyColumn, to denote the key in our Address that we want to map back to our Customer. When we look at the <dataset> used for testing this Entity, we can see that our ADDRESS_KEY and CUST_ID are merged into one table:
    
38. <CUST_ADDRESSES ADDRESS_KEY="Primary" CITY="Exton"
    
39. POSTCODE=""
    
40. PROVINCE="91335"
    
41. STATE="PA" STREET="555 Boot Road"
    
42. STREET2="b101" TYPE="RESIDENTIAL"
    
43. CUST_ID="102"/>
    
44. The ADDRESS_KEY denotes the Key used in the Map<K,V>, for our Address Object. Then we have a reference CUST_ID back to our Customer Table.

复制代码

1. Getting ready
   
2. 
   
3. Building upon the first recipe, we start with a customer, and we want to audit all CRUD operations that occur. We can achieve this in two basic ways:
   
4. 
   
5. Using @PrePersist and @PreUpdate annotations
   
6. Implement a JPA Lifecycle Change Listener
   
7. Using @PrePersist and @PreUpdate are simple and easy to implement. However, they are only going to allow for one revision to be saved. This might suffice for minimal auditing:
   
8. 
   
9. public static ThreadLocal currentUser = new ThreadLocal();
   
10. @Column(name = Constants.AUDIT_USER)
    
11. protected String auditUser;
    
12. @Temporal(TemporalType.TIMESTAMP)
    
13. @Column(name = Constants.AUDIT_TIMESTAMP)
    
14. protected Calendar auditTimestamp;
    
15. We need to add a property to our entity for holding the user that made the last update, and when the last update occurred. This gives us the managed properties we need in order to add our audit information.
    
16. 
    
17. How to do it...
    
18. 
    
19. To implement a single audit record implementation, we can simply add a service method to our Entity, which is annotated with @PrePersist or @PreUpdate respectively to be initiated during the respective lifecycle:
    
20. 
    
21. @PrePersist
    
22. @PreUpdate
    
23. public void updateAuditInfo() {
    
24. setAuditUser((String) currentUser.get());
    
25. setAuditTimestamp(Calendar.getInstance());
    
26. }
    
27. Usually you would create a super class that contains the properties you want to share with children. In this case, we have an AuditableEntity that is extended by customer. In this recipe, we have created an AuditableEntity that our customer extends.

复制代码