javaBean的四种保存范围是围绕四种内置对象而展开的，在前面的jsp内置对象详解中我们已经学习过了page、request、session和application。

在标签指令<jsp:useBean id="" scope="范围"/>中的scope就是属性范围，有page、request、session和application这四种语法

关于JavaBean的保存范围

   在<jsp:useBean>的指令上存在了另一个scope属性，表示的是一个javaBean的保存范围，保存的范围一共有四种：

      1.  page: 保存在一页的范围之中，跳转之后此javaBean无效了；

      2. request：一个javaBean对象可以保存在一次服务器跳转范围中；

      3.session：在一个用户的操作范围中保存，重新打开浏览器的时候才会声明新的javaBean；

      4.application：在整个服务器上保存，服务器关闭时才会消失

实例验证四种javaBean属性范围

下面做一个程序实例，是用于网页计数的。

先写一个javaBean，叫做count.java

 
  
  1. count.java  
  2. package javaBean01;    //放在包中  
  3. public class count {  
  4.       private int count=0;  
  5.       public count(){   // 无参构造 我们用来观察服务器用      
  6.           System.out.println("======一个新的count对象产生=====");  
  7.       }  
  8.       public int getCount(){   //实现累加计数功能  
  9.           return ++ this.count;  
  10.       }  
  11. }  
 
  
有了javaBean了，我们来做接受页面，叫做javaBean.jsp,这个页面的属性我们分别定义为page、request、session、application；
 
  
一。当属性是page的时候
 
  
 
  
  1. javaBean.jsp  
  2. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  3. <html> 
  4. <head> 
  5. <title>WEB开发项目</title> 
  6. </head> 
  7. <jsp:useBean id="cou" scope="page" class="javaBean01.count"/> 
  8. <body> 
  9. <h3>第<jsp:getProperty name="cou" property="count"/>次访问！</h3> 
  10. </body> 
  11. </html> 
 
  
运行一下javaBean.jsp页面，显示结果为第1次访问，然后刷新，不论怎么刷新都是第1次。因为我们定义的页面属性为page，只能在当前页面有效，服务器是不会累加的。 我们在来看一下服务器，此时的tomcat服务器如下图所示：
 
  
 
  
也就是说，随着页面的刷新，javaBean会自动生成一个count对象。刷新一次生成一个。如果我们让javaBean.jsp页面跳转到javaBean_01.jsp页面上又会是怎样的结果？
 
  
将javaBean.jsp改成如下，然后做javaBean_01.jsp页面，让javaBean.jsp跳转到javaBean_01.jsp上
 
  
 
  
  1. javaBean.jsp  
  2. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  3. <html> 
  4. <head> 
  5. <title>WEB开发项目</title> 
  6. </head> 
  7. <jsp:useBean id="cou" scope="page" class="javaBean01.count"/> 
  8. <body> 
  9. <h3>第<jsp:getProperty name="cou" property="count"/>次访问！</h3> 
  10. <jsp:forward page="javaBean_01.jsp"/> 
  11. </body> 
  12. </html> 
  13.     
  14. javaBean_01.jsp  
  15. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  16. <html> 
  17. <head> 
  18. <title>WEB开发项目</title> 
  19. </head> 
  20. <jsp:useBean id="cou" scope="page" class="javaBean01.count"/> 
  21. <body> 
  22. <h3>第<jsp:getProperty name="cou" property="count"/>次访问！</h3> 
  23. </body> 
  24. </html> 
 
  
这个时候运行一下javaBean.jsp页面，显示依然是第1次访问，但是看服务器，刷新一次页面就会有两个count对象产生，为什么是两个呢？ 在javaBean.jsp页面上生成一个，但是遇到page跳转后，它会再生成一个对象，所以就会产生两个页面。
 
  
二、当属性是request的时候
 
  
     当属性是page的时候，对象只在一个jsp文件中保存，那么要想在一次跳转中保存，肯定就是request属性了。
 
  
 
  
  1. javaBean.jsp  
  2. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  3. <html> 
  4. <head> 
  5. <title>WEB开发项目</title> 
  6. </head> 
  7. <jsp:useBean id="cou" scope="request" class="javaBean01.count"/> 
  8. <body> 
  9. <h3>第<jsp:getProperty name="cou" property="count"/>次访问！</h3> 
  10. <jsp:forward page="javaBean_01.jsp"/> 
  11. </body> 
  12. </html> 
  13.  
  14. javaBean_01.jsp  
  15. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  16. <html> 
  17. <head> 
  18. <title>WEB开发项目</title> 
  19. </head> 
  20. <jsp:useBean id="cou" scope="request" class="javaBean01.count"/> 
  21. <body> 
  22. <h3>第<jsp:getProperty name="cou" property="count"/>次访问！</h3> 
  23. </body> 
  24. </html> 
 
  
将属性改成request后，运行一下javaBean.jsp，此时浏览器上的显示由原来的第1次变成了第2次，之后将不再累加了，此时的服务器上只有一个对象产生，不论你怎么刷新，始终都是一个对象，也就是说它会在服务器上保存着。
 
  
   <jsp:useBean id="cou" scope="request" class="javaBean01.count"/>的好处是这条语句实际上节约了判断的步骤，节约了以下步骤：
 
  
     request。setAttribute（"cou",new count()）；
 
  
     第二个页面
 
  
   count  c=request.getAttribute("cou");
 
  
   if(c==null){ c=new count(); }
 
  
    c.getCount();
 
  
三、当属性是session的时候
 
  
因为是session，所以就不需要跳转页面了 ，因为不管是客户端还是服务器端都一样。那么此时只需要有一个javaBean.jsp即可。
 
  
 
  
  1. javaBean.jsp  
  2. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  3. <html> 
  4. <head> 
  5. <title>WEB开发项目</title> 
  6. </head> 
  7. <jsp:useBean id="cou" scope="session" class="javaBean01.count"/> 
  8. <body> 
  9. <h3>第<jsp:getProperty name="cou" property="count"/>次访问！</h3> 
  10. </body> 
  11. </html> 
 
  
运行一下，浏览器上随着页面的刷新，可以发现访问次数逐渐累加，刷新几次，级访问几次，而服务器上依然只有一个对象产生。但是重启一下浏览器就会发现，服务器上产生了一个对象，重启一次浏览器就产生一个对象。因为关闭浏览器后session就不存在了，重启后就会重新创建，也会重新产生一个新的count对象。
 
  
四、当属性是application的时候
 
  
当属性是application的时候那就更简单了，因为application是服务器的联系，只要服务器器不关闭，就会一直保持着。
 
  
 
  
  1. javaBean.jsp  
  2. <%@ page language="java" contentType="text/html" pageEncoding="utf-8"%> 
  3. <html> 
  4. <head> 
  5. <title>WEB开发项目</title> 
  6. </head> 
  7. <jsp:useBean id="cou" scope="application" class="javaBean01.count"/> 
  8. <body> 
  9. <h3>第<jsp:getProperty name="cou" property="count"/>次访问！</h3> 
  10. </body> 
  11. </html> 
 
  
运行一下，浏览器中随着页面的刷新，访问次数会不断增加，而服务器上始终都是一个对象。假设浏览器中刷新到了第6次访问，然后关闭浏览器，重新启动浏览器，此时会发现上来就是从第7次开始访问的。而重新启动浏览器后服务器依然是一个对象，不会再产生新的对象了。
 
  
至此，关于javaBean的属性范围我们就学习完了，注意的是一定要亲自运行代码，亲自观察服务器的对象产生，如果还是很乱的话，我们来一起做一个总结吧。
 
  
总结：
 
  
                       访问次数               服务器对象产生个数                                原因  
 
  
1.page            始终1次                   页面刷新一次产生一个                   page只在当前页面生效
 
  
2.request         始终2次                    刷新一次产生两个                           跳转会再生成一个对象
 
  
3.session         随着刷新累加          不随刷新增加，始终是一                session一次性会话机制
 
  
                      ，重启浏览器后        个，只有重启浏览器才会
 
  
                      从1次开始                   增加一个
 
  
4.application     随着刷新累加                不随刷新增加，始终是                 application是直接作用
 
  
                        重启浏览器后依然        一个，重启浏览器也                       于服务器的
 
  
                      从 上次访问次数开始      不会增加了
 
  
 
 
  
一定要注意：四种内置对象一定要弄明白是怎么回事，要理解它们的原理，把握好它们的核心，因为在之后的学习中四种内置对象依然是开发的重点。