Môn xử lý phân bố - Enterprice java bean (ejb)

Đại Học Quốc Gia Thành Phố Hồ Chí Minh Trường Đại Học Công Nghệ Thông Tin ---------- BÁO CÁO GIỮA KỲ MÔN XỬ LÝ PHÂN BỐ Đề Tài: Enterprice Java Bean (EJB) - Giảng viên :  Nguyễn Trác Thức - Sinh viên thực hiện :  Hoàng Văn Hà 09520074  Mai Văn Khải 09520133  Hồ Đức Lợi 09520162  Trần Trung Đức 09520067 TP.HCM, ngày 23 tháng 12 năm 2012 Lời Nói Đầu Enterprise Java Bean là các thành phần công nghệ phía máy chủ dùng để đóng gói lớp logic nghiệp vụ (business logic) và hổ trợ mạnh việc thực hiện các giao tác và bảo mật. Enterprise Java Bean cũng có một tích hợp một ngăn xếp cho messaging, scheduling, remote access, web service endpoints (SOAP and REST), dependency injection, component life cycle,..vv. Ngoài ra, Enterprise Java Beans còn kết hợp với các công nghệ khác của Java SE và Java EE như JDBC, JavaMail, JPA, Java Transaction API (JTA), Java Messaging Service (JMS), Java Authentication and Authorization Service (JAAS), Java Naming and Directory Interface (JNDI), and Remote Method Invocation (RMI). Ngày nay Enterprise Java Beans là một cách đơn giản cho các việc phát triển các mô hình lập trình Java phía máy chủ, giảm độ phức tạp trong khi mang lại khả năng tái sử dụng và khả năng mở rộng tới các ứng dụng thương mại quan trọng. Tất cả những điều đạt được này đều xuất phát từ một lớp java nguyên thủy(Plain old Java Object-POJO) sẽ được triển khai vào một thùng chứa (container). Chính vì vậy, nhóm chúng em sẽ tìm hiểu và trình bày về Enterprise Java Bean. Do trong quá trình tìm hiểu ít tài liệu và gấp rút về thời gian nên có thể còn nhiều sai sót. Mong nhận được góp ý của thầy và các bạn. 3 | T r a n g Mục Lục Bảng phân chia công việc nhóm ............................................................................................. 5 I. Message Driven Bean ......................................................................................................... 6 1.1. Một số khái niệm liên quan ........................................................................................... 6 1.1.1. Message .............................................................................................................. 6 1.1.2. Hệ thống EMS – Enterprise Message System ........................................................... 6 1.1.3. Hệ thống JMS - Java Message Service .................................................................... 7 1.2. Message Driven Bean .................................................................................................. 9 1.2.1. Giới thiệu ............................................................................................................ 9 1.2.2. Một số hàm cơ bản ..............................................................................................10 II. JAVA PERSISTENCE API ................................................................................................16 2.1. JDBC và ORM ...........................................................................................................16 2.1.1. JDBC là gì? ........................................................................................................16 2.1.2. ORM là gì? .........................................................................................................17 2.2. JPA là gì? ..................................................................................................................17 2.3. Entity ........................................................................................................................18 2.3.2. Entity .................................................................................................................19 2.4. Persistence Context.....................................................................................................23 2.5. Entity Manager ..........................................................................................................24 2.5.1. Thao tác với Entity ..............................................................................................24 2.5.2. Persistence Unit ..................................................................................................26 2.6. Java Persistence Query Language .................................................................................26 2.6.1. JPQL là gì ..........................................................................................................26 2.6.2. Cấu trúc truy vấn JPQL ........................................................................................27 2.6.3. Các kiểu query ....................................................................................................29 III. Transaction trong EJB ....................................................................................................33 3.1. Transactions ..............................................................................................................33 3.2. Container – managed transaction ..................................................................................33 3.2.1. Khái niệm ...........................................................................................................33 3.2.2. Transaction attribute ............................................................................................35 3.2.3. Thiết lập transaction attribute ................................................................................37 3.3. Bean – managed transaction .........................................................................................39 3.3.1. Khái niệm ...........................................................................................................39 3.3.2. Các method hỗ trợ ...............................................................................................40 3.3.3. Thiết lập transaction timeout với bean – managed transaction ...................................40 3.4. Xử lý exception ..........................................................................................................41 3.4.1. Trường hợp EJB với bean – managed transaction ....................................................41 3.4.2. Trường hợp EJB với container – managed transaction ..............................................41 4 | T r a n g IV. EJB Security .................................................................................................................42 4.1. Các khái niệm cơ bản ..................................................................................................43 4.1.1. Tổng quan ..........................................................................................................43 4.1.2. Các cơ chế áp dụng trong Security .........................................................................43 4.2. Mô hình J2EE Security ...............................................................................................44 4.3. JAAS Framework .......................................................................................................45 4.4. Security trên EJB ........................................................................................................49 V. Tài liệu tham khảo .............................................................................................................52 5 | T r a n g Bảng phân chia công việc nhóm stt Họ Tên thành viên Mã số sinh viên Công Việc 1 Hồ Đức Lợi 09520162 Tìm hiểu về EJB Security 2 Hoàng Văn Hà 09520074 Tìm hiểu về JPA, Entity, JPQL 3 Mai Văn Khải 09520133 Tìm hiểu về Message Driven Bean 4 Trần Trung Đức 09520067 Tìm hiểu về Transaction Processing 6 | T r a n g I. Message Driven Bean 1.1. Một số khái niệm liên quan 1.1.1. Message Khi một client gọi phương thức trên máy ở xa thì bản chất nó đã tạo ra một request và thread/process của nó sẽ bị block lại để chờ response trở về và có thể làm trì hoãn quá trình xử lý. Thay vì thế người ta đưa ra cơ chế giao tiếp bằng cách chuyển thông tin qua định dạng dùng chung qua đối tượng trung gian và không cần mong kết quả trả về. Cơ chế này đòi hỏi phải có đối tượng trung gian để nhận và chuyển message độc lập với việc xử lý. Cơ chế này còn cho phép khả năng truyền message đến nhiều hơn một đối tượng nhận cùng một lúc (broadcast). Cơ chế này có hạn chế đó là làm quá tải đối tượng trung gian. - Đối tượng theo định dạng giao tiếp dùng chung đó là message. - Đối tượng trung gian đó là MOM – Message Oriented Middleware hay MQ – Message Queue Hỗ trợ cơ chế tương tự như DB với việc nhận và gửi message, đảm bảo toàn vẹn dữ liệu, transaction và cân bằng cho việc gửi nhận dữ liệu Nơi lưu trữ dữ liệu và tương tác với MOM có tên gọi là Destination 1.1.2. Hệ thống EMS – Enterprise Message System Có hai loại giao tiếp: - Đồng bộ (synchronous): có nghĩa là các yêu cầu thông điệp phải chờ cho yêu cầu đang được xử lý hoàn tất trước khi tiếp tục (giống như một cuộc trò chuyện điện thoại – phải trò chuyện xong cuộc gọi hiện tại thì mới thực hiện cuộc gọi tiếp theo được). - Bất đồng bộ (asynchronous) có nghĩa là bạn không cần phải chờ đợi, chỉ là yêu cầu của bán sẽ được hoàn thành ở một khoảng thời gian sau đó (giống như một cuộc điện thoại tư vấn, hy vọng cuộc gọi của bạn sẽ được nghe). EMS cung cấp cơ chế gửi nhận message đồng bộ và bất đồng bộ. Người gửi gửi message đến middleware, middleware tự chuyển message đến người nhận, khi tác vụ 7 | T r a n g truyền hoàn tất thì người nhận sẽ gửi tín hiệu đến middleware thông báo hoàn tất tác vụ (đây là cơ chế gửi nhận message bất đồng bộ) Hệ thống EMS có thể nhìn tương đương cuộc sống thực tế chính là hệ thống gửi nhận SMS của chúng ta theo cách nhìn đó là điện thoại gửi tin nhắn cho nhau thông qua tổng đài, và máy chúng ta nhận tin nhắn tự động là do tổng đài đưa tin nhắn đến máy và tín hiệu phản hồi thể hiện cho chúng ta biết người nhận có nhận hay chưa. Bên cạnh đó, người nhận tin nhắn không cần bật điện thoại tại thời điểm gửi. Hệ thống EMS cũng giống tương tự hệ thống khác đó là email, cho phép lưu trữ message và sau đó người dùng sử dụng account với quyền xác thực truy cập vào mail server để lấy thông tin về message theo nghĩa chúng ta không gửi mail cho nhau mà gửi thông qua object trung gian 1.1.3. Hệ thống JMS - Java Message Service Java Message Service (JMS) là một API cho thông điệp máy khách Java (Java messaging clients). JMS cung cấp 2 môi trường lập trình là điểm-điểm (Point-to- Point) và Xuất bản và đăng ký (publish-and-subscribe). - Mô hình Point-to-Point messaging dùng cho việc chuyển giao các thông điệp theo kiểu 1-1, tức là mỗi thông điệp chỉ được nhận 1 lần bởi 1 client. Nó được xây dựng dựa trên khái niệm message queue (hàng các thông điệp). Mỗi thông điệp được gửi tới một hàng được chỉ định; clients nhận các thông điệp từ hàng được thiết lập để giữ các thông điệp này. Hình sau chỉ cho chúng ta vài tình huống trong cơ chế truyền thông điệp Point-to-Point. 8 | T r a n g Như chúng ta thấy trong hình trên, một hàng có thể có nhiều người gửi thông điệp và có nhiều người nhận nhưng chỉ 1 người nhận nhận một thông điệp trong hàng. Tuy nhiên, trong Point-to-Point model, client có thể chọn thông điệp mà nó cho phép viếng thăm nhưng không lấy giá trị (peek). - Mô hình Pub/Sub messaging dùng cho việc phát tán các thông điệp (one-to-many broadcast). Nó được xây dựng trên khái niệm về chủ đề các thông điệp (message topic). Mỗi thông điệp được đăng (publish) lên 1 chủ đề (topic) sẽ được phát tán cho tất cả các clients mà có đăng ký (subscibe) chủ đề này. Đối tượng Topic được đóng gói trong 1 tên được chỉ định bởi nhà cung cấp dịch vụ. Điều này tương tự như khái niệm newsgroups, user đăng ký chủ đề mà mình yêu thích, mỗi user sẽ nhận được 1 bản copy của thông điệp đăng lên newsgroup mà mình đăng ký. Hình sau chỉ cho chúng ta một số tình huống của cơ chế truyền thông điệp Pub/Sub. 9 | T r a n g Trong mô hình Pub/Sub, một JMS client có thể là 1 durable subscriber để có thể ngắt kết nối và sau này nối lại để lấy các thông điệp mà mình đã đăng ký. JMS API cung cấp tất các mọi chức năng hỗ trợ tạo, thêm, xóa, gửi và nhận message. 1.2. Message Driven Bean 1.2.1. Giới thiệu Message-Driven bean (MDB) là một component nhẹ nhàng được sử dụng để giao tiếp thông qua tin nhắn (Ví dụ như email hoặc tin nhắn IM). Trong MDB, dịch vụ gửi tin ở trong chế độ không đồng bộ vì người dùng không yêu cầu có kết quả ngay lập tức MDB có thể thực thi bất kỳ loại tin nhắn nào. Thông thường nhất, chúng thực thi kỹ thuật Java Message Service (JMS). MDB có những đặc điểm sau đây : 10 | T r a n g - Một thực thể của MDB không lưu lại dữ liệu hoặc trạng thái của cuộc trò truyện cho một client cụ thể. - Một MDB duy nhất có thể xử lý các tin nhắn từ nhiều client. - Chúng không đại diện cho dữ liệu chia sẻ trực tiếp trong cơ sở dữ liệu, nhưng chúng có thể truy cập và cập nhật dữ liệu này. - Một MDB chỉ có một lớp đối tượng, không giống với session bean, client không truy xuất MDB qua giao diện (interface). - Chúng không có các interface từ xa hoặc cục bộ để xác định các truy cập của client. Sơ đồ sau sẽ cho ta thấy quy trình làm việc của một MDB Trong MDB, các thành phần phía client không xác định được Message-Driven beans và gọi các hàm một cách trực tiếp. mà thay vào đó là các máy chủ JMS sẽ gửi tin nhắn cho hàng đợi tin nhắn được quản lý bởi máy chủ JMS (Ví dụ một hộp thư email cũng là một hàng đợi tin nhắn) mà các interface javax.jms.MessageListener được thực thi. Hàng đợi thông điệp được giám sát bởi một loại đặc biệt của EJB(s) - Message Driven Beans (MDBs) nó xử lý các tin nhắn đến và thực hiện các dịch vụ theo yêu cầu của tin nhắn. MDBs là điểm cuối cho dịch vụ JMS yêu cầu thông điệp. bạn gán một MDBs đích trong quá trình triển khai bằng cách sử dụng các nguồn tài nguyên máy chủ ứng dụng. 1.2.2. Một số hàm cơ bản 11 | T r a n g Dể tìm hiểu về một số hàm cơ bản trong MDBs, chúng ta đi qua ví dụ sau : Ví dụ của chúng ta sẽ giả định dùng mô hình Point-to-Point và yêu cầu thiết lập một hàng đợ với QueueConnectionFactory trong JMS. Trong ví dụ này, chúng ta sẽ thực thi một ứng dụng MDB có tên masage chứa các thành phần sau : - Một ứng dụng client dùng để gửi thông điệp tới một hàng đợi : MessageClient - Một message-driven bean bất đồng bộ tiếp nhận và xử lý các tin nhắn được gửi đến hàng đợi : MessageBean Code cho ứng dụng client package message_mdb_demo; import javax.annotation.Resource; import javax.jms.*; @Resource(mappedName="jms/Queue") public class MessageConn { private static Queue queue=null; QueueConnectionFactory factory=null; QueueConnection connection=null; QueueSender sender=null; QueueSession session=null; public MessageConn() { try { //client tạo các connection, session, and message sender: connection=factory.createQueueConnection(); session=connection.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE); sender=session.createSender(queue); //Tao va cau hinh mot Message de gui TextMessage msg=session.createTextMessage(); for(int i=0;i<5;i++) { msg.setText("this is my Message number " + (i + 1)); 12 | T r a n g //Client gui mot message khong dong bo den Queue sender.send(msg); } System.out.println("Sending Message..."); session.close(); } catch (Exception e) { e.printStackTrace(); } } } Trong đoạn mã trên, gói javax.jms.* được import vào để tạo ra các hàng đợi từ các lớp Queue, QueueConnectionFactory, QueueConnection, QueueSender và QueueSession. Sau khi có được đối tượng QueueConnectionFactory, ta sử dụng hàm createQueueConnection của nó để xây dựng một đối tượng QueueConnection như thế này: connection = factory.createQueueConnection( ); sau đó, bạn sử dụng hàm createQueueSession của giao diện QueueConnection để tạo ra một đối tượng QueueSession như mã sau: session = connection.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE); chú ý rằng bạn chọn false cho tham số đầu tiên của hàm createQueueSession là để biểu thị rằng bạn không tạo ra một đối tượng transactional session. Tiếp theo, bạn có thể gọi hàm createSender của interface QueueSession. Tham số truyền vào là một đối tượng Queue. Giá trị trả về của hàm này là một đối tượng tạo ra message. Đó là một QueueSender. sender = session.createSender(queue); sau đó, một đối tượng TextMessage dựa trên các Message nhận được bằng cách duyệt qua các Text của TextMessage để gọi hàm createTextMessage của đối tượng QueueSession và sau đó gán text cho đối tượng TextMessage. 13 | T r a n g TextMessage msg = session.createTextMessage( ); msg.setText("This is my sent message " + (i + 1)); bây giờ, Message đã sẵn sàng được gửi. chúng ta có thể gửi Message bằng cách gọi hàm send của đối tượng QueueSender: sender.send(msg); quá trình kết nối của MDBs có thể được thấy giống với sơ đồ sau: Hàm đặc tả @Resource đặc tả sự phụ thuộc vào một tài nguyên bên ngoài như một nguồn dữ liệu JDBC hoặc một đích đến JMS hoặc một connection factory. Nếu bạn sử dụng các chú thích (annotation) vào một class thì chú thích đó sẽ khai báo tài nguyên mà bean sẽ cần tìm kiếm khi khởi chạy. Tham số mappedName của chú thích Resource đặc tả một tên JNDI toàn cục của các tài nguyên lệ thuộc. ví dụ: @Resource(mappedName ="jms/Queue") Đặc tả tên JNDI của tài nguyên lệ thuộc là jms/Queue và được triển khai trên máy chủ JEE. Trong một ứng dụng web-client, tham số "jms/Queue" và “ConnectionFactory” đã được sử dụng trong JNDI lookup. Cả hai cái tên JNDI và sử dụng cacs kết nối từ 14 | T r a n g bên ngoài được cung cấp bởi các bộ chuyển đổi tài nguyên JMS. Việc thực hiện tìm kiếm JNDI để sử dụng cho một dịch vụ web như sau: InitialContext ctx = new InitialContext(); queue = (Queue) ctx.lookup("jms/Queue"); QueueConnectionFactory factory = (QueueConnectionFactory) ctx.lookup("ConnectionFactory"); connection = factory.createQueueConnection(); session = cnn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE); Code cho message-driven bean: package mdb; import javax.ejb.*; import javax.ejb.MessageDriven; import javax.jms.Message; import javax.jms.MessageListener; import javax.jms.ObjectMessage; import java.text.*; import javax.naming.*; import java.util.logging.Logger; @MessageDriven(mappedName="jms/Queue") public class MessageBean implements MessageListener { @Resource private MessageDrivenContext mdc; private static final Logger logger; public void onMessage(Message msg) { TextMessage tmsg = null; try { 15 | T r a n g tmsg = (TextMessage) msg; logger.info("MESSAGE BEAN: Message received: " + tmsg.getText( )); System.out.println ("The onMessage() is called"); } catch (JMSException e) { e.printStackTrace( ); mdc.setRollbackOnly( ); } catch (Throwable th) { th.printStackTrace(); } } public void ejbRemove( )throws EJBException{ loger.fine("ejbRemove()"); } } Lớp MessageBean thể hiện các yêu cầu dưới đây: Trong EJB 3.0, lớp MDB được chú thích với @MessageDriven mà đặc tả các message queue theo dõi MDB (ví dụ: jms/Queue). Nếu hàng đợi không tồn tại, các EJB container tự động tạo ra nó ở thời gian triển khai. Không có tập tin cấu hình XML cần thiết! Đối với các máy chủ ứng dụng, các chú thích @MessageDriven thường chứa một thuộc tính mappedName chỉ định tên JNDI của điểm đích mà từ đó, các bean sẽ xử lý các message. Các class phải được đặt ở chế độ public và phải có một public constructor mặc định. Nó không phải định nghĩa ra các hàm finalize. Một lớp MDB nên thực thi interface MessageListener cho các loại Message mà nó hỗ trợ. Interface này định nghĩa một hàm duy nhất đó là