Java 里 Stateless vs Stateful, Remote vs Local, Persistence 的意思

jangancari

根据我读的资料， Stateless Bean 在技术上的解释是不同的JVM 上运行的Java程序是无法access 彼此的。而Stateful Bean 是可以的。

Remote 和 Local 则是会分别 这个bean 可不可以被其他的机器上Java 程序呼叫或access。

我还不是明白得非常透彻， 恳请Java 高手可以能以 Web based database app  为例子， 加少许的coding 比较， 来解释这些term 。

谢谢。

winmxaa

原帖由 jangancari 于 15-4-2008 11:32 AM 发表
根据我读的资料， Stateless Bean 在技术上的解释是不同的JVM 上运行的Java程序是无法access 彼此的。而Stateful Bean 是可以的。

Remote 和 Local 则是会分别 这个bean 可不可以被其他的机器上Java 程序呼叫或ac ...

Stateless session beans do not maintain the conversational state associated with any client.
意思是说”Stateless session beans“ 做的东西，没有对应任何client.
例：
读取某product的price.
比如有5个client同时create "Stateless session beans", 去读取某product的price.
那return 回来的price直接(胡乱 ps*)丢给任何个client.
因为每个price是同样 value的。

ps*:

--其实不能酱”胡乱“，它是会用最后一个值，看以下例子：
Less s[] = new Less[5];
        for(int i = 0 ; i < 5 ; i ++ ){
            s = home.create();
            s.setCount(i);
        }
        for(int i = 0 ; i < 5 ; i ++){
            System.out.println(s.getCount());
        }
   那打印出来的是：
   5
   6
   7
   8
   9
原因：当他setCount时，最后已经set去“4”了，所以print出来是从“5”开始。

Stateful session beans maintain the state associated with a client.
意思是说”Stateful session beans“ 做的东西，有对应任何client.
例：
购物车
比如有5个client同时create "Stateful session beans", 大家同时有了一辆购物车
那每个client所买的东西是不同的，
所以每辆购物车是有固定的client.

[ 本帖最后由 winmxaa 于 15-4-2008 09:01 PM 编辑 ]

jangancari

谢谢你清楚的解释，明白了Stateful 和 Stateless Session Bean 的分别与功能了。

我还有一个疑问， 如果一个Stateful Session Bean declare 了 Stateless Session Bean 的  instance (object) ， 那么那个object 是Stateful 还是stateless ? vice-versa 呢？

以下例子里 LibraryCart 是 Stateful ， BookDaoImp 是 Stateless 。


例子：

1. @Stateless
   
2. public class BookDaoImp implements BookDao {
   
3. 
   
4.         @PersistenceContext
   
5.         private EntityManager em;
   
6. 
   
7.         private Logger log = Logger.getLogger(this.getClass());
   
8. 
   
9.         public void save(Book book) {
   
10.                 log.debug("Persist book: " + book);
    
11.                 em.persist(book);
    
12.         }
    
13. 
    
14.         public void merge(Book book) {
    
15.                 em.merge(book);
    
16.         }
    
17. 
    
18.         public List findAll() {
    
19.                 log.debug("find All books");
    
20.                 return em.createQuery("from Book").getResultList();
    
21.         }
    
22. 
    
23.         public static final String RemoteJNDIName = BookDaoImp.class
    
24.                         .getSimpleName()
    
25.                         + "/remote";
    
26. 
    
27.         public static final String LocalJNDIName = BookDaoImp.class.getSimpleName()
    
28.                         + "/local";
    
29. 
    
30.         public Book findById(Integer id) {
    
31.                 return em.find(Book.class, id);
    
32.         }
    
33. 
    
34.         public List findByCustomer(Customer customer) {
    
35.                 log.debug("find by customer");
    
36.                 return em.createQuery("from Book b where b.customer = :customer")
    
37.                                 .setParameter("customer", customer).getResultList();
    
38.         }
    
39. }
    
40. 
    
41. 
    
42. 
    
43. 
    
44. 
    
45. ＝ ＝ ＝ ＝ ＝
    
46. 
    
47. 
    
48. 
    
49. @Stateful
    
50. public class LibraryCart implements LibraryCartLocal {
    
51.         @PersistenceContext
    
52.         private EntityManager em;
    
53. 
    
54.         private Logger log = Logger.getLogger(this.getClass());
    
55. 
    
56.         private Map<Integer, Book> books = new HashMap<Integer, Book>();
    
57. 
    
58.         public static final String RemoteJNDIName = LibraryCart.class
    
59.                         .getSimpleName()+ "/remote";
    
60.         public static final String LocalJNDIName = LibraryCart.class
    
61.                         .getSimpleName()+ "/local";
    
62. 
    
63.         public void addBook(Book book) {
    
64.                 if (books.get(book.getId()) == null)
    
65.                         books.put(book.getId(), book);
    
66. 
    
67.         }
    
68. 
    
69.         public void addBook(Integer id) {
    
70.                 if (books.get(id) == null)
    
71.                 {
    
72.                         BookDao bookDao;
    
73.                         try
    
74.                         {
    
75.                                 Context context = new InitialContext();
    
76.                                 bookDao = (BookDao) context.lookup(BookDaoImp.LocalJNDIName);
    
77.                         } catch (NamingException e)
    
78.                         {
    
79.                                 e.printStackTrace();
    
80.                                 throw new RuntimeException(e);
    
81.                         }
    
82.                         Book book = bookDao.findById(id);
    
83.                         if (book != null)
    
84.                                 books.put(id, book);
    
85.                 }
    
86. 
    
87.         }
    
88.   略。。
    
89. 
    
90. }

复制代码

苦瓜汤

BookDao还是Stateless  Stateless Bean再Context的Stateless Pool里面只有一个Instance

jangancari

谢谢大家的解释，受益良多。