1、1968年软件危机后提出软件工程的概念和方法，即软件工程是将系统化的、规范化的、数量化的工程原则及方法应用于软件的开发运维。根据FRED BROOKS在《人月神话》中的观点，软件系统是人类所创造的最复杂的系统。因其复杂性，我们的目标是开发高品质的软件和互联网产品服务，于是用过程来规范人的行为，用方法来帮助人们处理复杂性，用工具来更好地贯彻这些过程和方法，简称工作流程化，流程工具化。
    一般来说，没有十全十美的过程，关键还是一个fit！即适合的组织文化，而又开发成本最小、发布产品最快、产品质量最好的过程就是好过程，甚至对一个组织，如果有不同类型的项目，可以几种方法并存，总之，不断吸收已有过程的思想，取长补短，实践持改，最终会形成适合自己企业的过程方法。

1、每个员工至少有两个"头"，一个是组织的"manager"，一个是项目的“leader”。请特别注意这个词，manager是组织赋予的正式权力，Leader是靠影响力而不是权力....
中国员工在刚开始实施矩阵时会有不少问题，最核心的是对PM的理解。简言之，PM角色是三合一：一、PM是Project Leader，即子项目负责人，或Project owner，落单责任人，当我们把大产品切片成多个可执行的小项目模块后，一般而言PM是细分小项目的一把手；二、PM是facilitator,资源协调人，PM可以跨职能组向其他职能经理申请其下项目需要的资源...........当然了，一个PM还要学会如何运转、控制工程资源并发矩阵，特别是在小公司，有时一个人要肩负几种产品角色；三、PM是coordinator，各方沟通、矛盾的调解人，例如开发和测试的矛盾可以通过三方会审机制Triage的方式解决。最后一个问题，PM不是boss，员工的boss是职能经理。
PM的权威是靠软性的影响力、领导力而不是靠组织赋予的刚性权力.......

2、事实是产品和公司的生命线，专业化管理的最高水平就是有能力从员工哪里获得真正的事实。统计显示大部分的冲突都是与沟通相关，所以，公司需要有一个有效的覆盖全公司的沟通渠道，并且每个员工都知道并能有效地使用它。

3、中国传统的儒家的人才标准是德才兼备，围绕着德和才有四种组合，第一级有德有才，其次是有德无才，第三无德无才，儒家认为最坏的人是无德有才。王充曾云“德不优者，不能怀远”，司马光说“德胜才谓之君子，才胜德谓之小人”，曾国藩说“识人方法有三，一曰德，二曰量，三曰才....被此三者，然后胜肱骨之任”。但是，西方管理认为，德能是不会自动转为才能的，即高度职业化的专业技能只能来自亚当.斯密在《国富论》中所说的“分工”后的重复行为实践，而不是来自爱岗敬业的工作精神。
通用电气前CEO杰克.韦尔奇定义了招聘的目标，是得到赛场上最合适的选手，其第一层面要求招聘的每个人都必须具备的正直、智慧和成熟的三要素。正直指诚实、守信、有责任心，勇于承认错误并改正；了解并遵守法律、行规以及公司各项规章制度；遵守游戏规则，用光明正大的手段争取胜利。智慧指是否有强烈的求知欲，是否有宽广的知识面，是否聪明。成熟的特征是是否能控制怒火，是否能承受压力和挫折等。
然后在第二层面上，努力去寻找具有4E/1P特点的人：Energy指有所作为的精神，渴望行动，喜欢变革，热爱工作，热爱生活，热爱享受。Energize，指对业务有精深的了解，有出色的说服技巧，能鼓舞自己的团队。Edge，指知道什么时候应停止评论，做出坚决的决定。Execute，指是否有将决定付诸行动，并继续向前推进，最终完成目标。Passion，指对工作有一种衷心的、强烈的兴奋感，热爱学习，热爱进步。

(1)首先是做正确的事，即设定目标、切割项目、责任落单；其次是用正确的人，即通过岗位设计和企业级沟通有效组织员工，通过人员配备和培训来发展员工，通过核心价值和绩效考核来激励员工；最后是正确地做事，使工作流程化、流程工具化。

(2)生活的确是黑暗的，除非有了渴望；所有的渴望都是盲目的，除非有了知识；一切知识都是徒然的，除非有了工作；所有工作都是空虚的，除非有了爱；

2、hibernate对象的三种状态
详细解释见视频第5课--实体对象的三种状态与saveOrUpdate方法
【1】瞬时(transient)
【2】持久(persistent)
【3】脱管(detached)

在持久状态的对象发生变化时，hibernate都能发现并且将持久层对象的改变传递到数据库的记录。
但是，为了减少持久层对象和数据库的交互，直到commit时才提交改变到数据库。

脱管对象因为没有处在hibernate的监听下，所以对象改变不会影响数据库记录的改变。

 

刚才在网上找工作，不仅纳闷在武汉好公司在哪里？

一些公司的介绍本身就很马虎，却在招聘信息中要求招聘人员“积极主动”，一般说这类要求的都是废话，谁找工作时不想表现得“积极主动”？感觉看外企招聘要求就非常正规，要求什么工作岗位能力说得很清楚，对编程语言要求、对数据库要求、对框架要求程度根据工作岗位性质不同，不像国内企业，什么都要求精通、熟悉，但是实际却用不上，工资还只开2000多，纯粹是浪费大家的时间。

通过招聘信息，可以发现好企业对员工的培训也很重视，通常有培训员工的计划和实例。但是私企就差很多，简直卖给他就像是准备剥削的！

我想，看来以后还是只能找外企、有实业背景的国企为依靠，私企民企是万万不可取的，多是些想捞一票就拉倒，不想长久发展的公司——至少在武汉是这样。

有人说武汉的外企主要是在圈子内靠互相推荐，不知道如何才能进“圈子”，不过我也没那么多时间来套圈子。说到底，还是要靠自己努力，先把今年年底拿了OCP，到时候再看看吧。

从工资体系上看，高薪的工资很多还是要研究生门槛的，但是我不想浪费时间去考，再说也觉得读个研究生对自己实力不会有大的提升，相反把时间浪费在给导师打工上了——不过据说导师可以帮助推荐好工作，但是我只能走另一条路了。

从工作要求上来，JAVA开发人员还是要求那些，对常用框架熟悉，熟悉数据库——我选择ORACLE，有项目经验和行业背景，再就是什么团队精神等等。其实真正还是经验，java语言就那么个语法，你学我学能有什么区别、oracle等数据库也是,都可以学——比如paperOcp,真正有用的是经验，有经验就能解决问题。

但是经验是要工作来积累的，没有相应的工作环境和项目体验，没有可供解决的问题，哪来的工作经验？这点上，也许就是我还留在现在公司的原因，虽然工资少，但是至少提供工作经验，还有些我可以学习的东西。

我计划明年2月份找一份8K的工作，但是限于武汉市，想想应该也太难，只要今年能完成几项任务：
1、拿到OCP；
2、通过近半年时间的工作积累，熟悉常用开发框架——精通我不敢说，那太困难，而且关键是这个玩艺要项目和时间来积累；
3、掌握一套好的程序设计的思想和分析模式，最近一段时间工作让我感觉这个东西对程序员来说太重要了，其实写程序大家都会写，但是怎么写才能满足功能、提高性能，又好维护，就这这套方法论了。其实我想作为程序员没有别的什么可以比出高下，类、方法查API就可以了，但是这个却是时间和经验积累的。

大致这样吧，今天总结了一下，留给以后忘记时提醒自己。

javascript中的this,我研究一段时间以后感觉没有一条完整的规律可以遵循，只能根据不同的语境来分别理解，所以要记忆，今天整理列出来：

1\Calling an Object’s Method

In typical object-oriented programming, we need a way of identifying and referring to the object that we’re currently working with. this serves the purpose admirably, providing our objects the ability to examine themselves, and point at their own properties.

 <script. type="text/javascript">
  var deep_thought = {
   the_answer: 42,
   ask_question: function () {
    return this.the_answer;
   }
  };
 
  var the_meaning = deep_thought.ask_question();
 </script>

 setting this to the object referenced by whatever came before the last ”.”

2\Constructor

Likewise, when defining a function to be used as a constructor with the new keyword, this can be used to refer to the object being created. Let’s rewrite the example above to reflect that scenario:

 <script. type="text/javascript">
  function BigComputer(answer) {
   this.the_answer = answer;
   this.ask_question = function () {
    return this.the_answer;
   }
  }
 
  var deep_thought = new BigComputer(42);
  var the_meaning = deep_thought.ask_question();
 </script>

this means “whatever deep_thought refers to”. this is not read from the scope chain as other variables are, but instead is reset on a context by context basis.

this意思是"deep_thought指向的任何地址"，this不像其它变量一样从scope chain读取，而是根据上下文基础重置

对这段不是理解清楚，感觉就是在内存里重新划了一块地方,this指向了这里

3\Function Call

What if we just call a normal, everyday function without any of this fancy object stuff? What does this mean in that scenario?

 <script. type="text/javascript">
  function test_this() {
   return this;
  }
  var i_wonder_what_this_is = test_this();
 </script>

In this case, we weren’t provided a context by new, nor were we given a context in the form. of an object to piggyback off of. Here, this defaults to reference the most global thing it can: for web pages, this is the window object.

4\Event Handler

有两种情况，第一种，触发事件写在标签里，如下

<script. type="text/javascript">
  function click_handler() {
   alert(this); // alerts the window object
  }
 </script>
 ...
 <button id='thebutton' onclick='click_handler()'>Click me!</button>

then, this is window

第二种，触发事件写在脚本里

 <script. type="text/javascript">
  function click_handler() {
   alert(this); // alerts the button DOM node
  }
 
  function addhandler() {
   document.getElementById('thebutton').onclick = click_handler;
  }
 
  window.onload = addhandler;
 </script>
 ...
 <button id='thebutton'>Click me!</button>

then, this is the DOM element that generated event

5\Complications

Let’s run with that last example for a moment longer. What if instead of running click_handler, we wanted to ask deep_thought a question every time we clicked the button? The code for that seems pretty straightforward; we might try this:

<script. type="text/javascript">
 function BigComputer(answer) {
  this.the_answer = answer;
  this.ask_question = function () {
   alert(this.the_answer);
  }
 }
 
 function addhandler() {
  var deep_thought = new BigComputer(42),
   the_button = document.getElementById('thebutton');
 
  the_button.onclick = deep_thought.ask_question;
 }
 
 window.onload = addhandler;
</script>

same as up example two ,this is the DOM element that generated event

共这5种情况，应该是比较全面了

同时也学习解决作用域的办法——使用bind,如下

<script. type="text/javascript">
 var first_object = {
  num: 42
 };
 var second_object = {
  num: 24
 };
 
 function multiply(mult) {
  return this.num * mult;
 }
 
 Function.prototype.bind = function(obj) {
  var method = this,
   temp = function() {
    return method.apply(obj, arguments);
   };
 
  return temp;
 }
 
 var first_multiply = multiply.bind(first_object);
 first_multiply(5); // returns 42 * 5
 
 var second_multiply = multiply.bind(second_object);
 second_multiply(5); // returns 24 * 5
</script>

 就可以圆满解决问题，非常棒！

注意：例子中有些问题，比如function(){statemnt,statemnt}不能使用“,”隔开，但是例子可能是在FF下运行的，通过适当调整可以在IE下运行

该组件使用的情况如下：
1、修改web.xml文件，为servlet增加一个参数作为上传路径

  <servlet>
    <description>This is the description of my J2EE component</description>
    <display-name>This is the display name of my J2EE component</display-name>
    <servlet-name>uploadFileServlet</servlet-name>
    <servlet-class>com.kursk.uploadFileServlet</servlet-class>
    <init-param>
    <param-name>url</param-name>
    <param-value>uploads</param-value>
    </init-param>
  </servlet>

2、uploadFileServlet

 private String savePath;//获取上传路径
 ServletContext sc;

 public void init(ServletConfig config) {
  savePath = config.getInitParameter("savePath");;//获取上传路径
  sc = config.getServletContext();//获取servlet地址
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  request.setCharacterEncoding("UTF-8");
  DiskFileItemFactory factory = new DiskFileItemFactory();
  ServletFileUpload upload = new ServletFileUpload(factory);
  try {
   List items = upload.parseRequest(request);//把文件从客户端上传到服务器内存
   Iterator itr = items.iterator();
/*
上传后，form表单的所有内容，文件(二进制),文本域(字符串)都被上传到了服务器端的内存，用itr来得到这些对象
*/
   while (itr.hasNext()) {//于是开始循环，对文件和文本域分别处理
    FileItem item = (FileItem) itr.next();//FileItem是upload组建中的一个对象，用于处理上传的对象
    if (item.isFormField()) {//这个方法判断是否是文本域，是，返回true；否则false
     System.out.println("表单参数名:" + item.getFieldName() + "，表单参数值:" + item.getString("UTF-8"));
    } else {//下面是文件的处理方法
     if (item.getName() != null && !item.getName().equals("")) {
      System.out.println("上传文件的大小:" + item.getSize());
      System.out.println("上传文件的类型:" + item.getContentType());
      // item.getName()返回上传文件在客户端的完整路径名称
      System.out.println("上传文件的名称:" + item.getName());

      File tempFile = new File(item.getName());//item.getName()得到是全路径，用File.getName()来得到单独文件名
      File file = new File(sc.getRealPath("/") + savePath, tempFile.getName());
      System.out.println(sc.getRealPath("/") + savePath);
      item.write(file);//这才是把文件从服务器内存上传到服务器硬盘
      request.setAttribute("upload.message", "上传文件成功！");
     }else{
      request.setAttribute("upload.message", "没有选择上传文件！");
     }
    }
   }
  } catch (Exception e) {
   e.printStackTrace();
   request.setAttribute("upload.message", "上传文件失败！");
  }
  request.getRequestDispatcher("/uploadResult.jsp").forward(request, response);
 }

servlet过滤器原理

使用Filter的步骤：
1、在web.xml中增加Filter

<filter>
    <filter-name></filter-name>
    <filter-class></filter-class>
    <init-param>
      <param-name>url</param-name>
      <param-value>/admin/login.jsp</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name></filter-name>
    <url-pattern></url-pattern>
</filter-mapping>

2、import javax.servlet.Filter
init()
doFilter()
destroy()

我理解servlet的监听器与数据库里的触发器类似，当在web应用中，特定对象发生特定的行为时，就调用监听器对象的特定方法。

监听器主要是针对HttpSession\Context\HttpRequest对象

(1)与HttpSession有关的监听器有4个

1\HttpSessionListener 需要在web.xml文件里注册
SessionCreated()    当session产生时调用
SessionDestroyed()  当session结束时调用

web.xml文件注册方法
<listener>
 <listener-class>packeg.class</listener-class>
</listener>

2\HttpSessionAttributeListener 需要在web.xml文件里注册
attributeAdded()
attributeReplaced()
attributeRemoved()

触发代码
Session.setAttribute()
Session.RemoveAttribute()

3\HttpSessionBindingListener  不需要在web.xml文件里注册
valueBound()
valueUnbound()

这个类与其它的类不同。当一个类继承了HttpSessionBindingListener接口，当这个类的对象通过Session.setAttribute()方法注册到session中时，valueBound()被调用；当这个对象被在session中删除时(调用session.invalidate()\session.removeAttribute()\或session对象过期),valueUnbound()方法被调用

4\HttpSessionActivationListener
SessionDidActivate()  活化后调用
SessionWillPassivate() 钝化前调用
活化Activate()与钝化Passivate()是web容器为了更好的利用系统资源或者进行服务器负载平衡等原因而对特定对象采取的措施。
会话对象的钝化指的是暂时将会话对象通过对象序列化的方法存储到硬盘上，而会话对象活化与钝化相反，web容器把硬盘上的存储的会话对象文件重新加载到web容器中

(2)与context有关的监听器有2个
1\ ServletContextListener
ContextInitialized()  在web应用被部署后调用
ContextDestroyed()    删除web应用或停止web应用时调用

2\ ServletContextAttributeListener
attributeAdded()
attributeReplaced()
attributeRemoved()

(3)与 request有关的监听器有2个
1\ServletRequestListener
requestInitialized()
requestDestroyed()

2\ServletRequestAttributeListener
attributeAdded()
attributeRepalce()
attributeRemoved()

JSTL是利用jst标记库技术而来，并在java ee 5.0作为标准技术。全名：JavaSever Pages Standard Tag Library,包括5个标记库

name	uri	prefix
Core	http://java.sun.com/jsp/jstl/core	c
Formate	http://java.sun.com/jsp/jstl/fmt	fmt
Sql	http://java.sun.com/jsp/jstl/sql	sql
Xml	http://java.sun.com/jsp/jstl/xml	xml
Functions	http://java.sun.com/jsp/jstl/functions	fn

一、Core 标记库
1、out标记

属性	说明	EL	必选	缺省值
value	el或常量	是	是	无
default	value为空时输出的内容	是	否	无
escapeXml	true:对输出内容的html\javascripts进行过滤	否	否	true

！note：可以把缺省值放在<></>中间，当value为空时，则会输出body部分的内容；

2、set标记
两种功能如下：

给指定的变量赋值	<c:set value="value" var="name" [scope=]/>
	<c:set var="name" [scope=""]>value</>
给一个对象的属性赋值	<c:set target="" value="" property=""></>
	<c:set target="" property="">value</>

说明如下：

属性	说明	EL	是否必须	缺省
value	要保存的内容，可以为EL或常量	可以	是	无
target	一般为javabean对象	可以	否	无
var	要保存的变量名	否	否	无
property	对象的属性名	否	否	无
scope	变量范围	否	否	page

3、<c:remove var="" scope=[]>
remove用来删除某个指定的变量

4、<c:catch var="">用来捕获错误信息，放在指定的变量里

5、if 标签
test 条件，实质返回它一个true/false,就执行/不执行body部分的代码
var  保存test结果的变量名
scope 保存var的范围

6、choose标签 when otherwise
相当于switch case defaulst

7、foreach 标签，一个很重要的标签，用于对数组、map赋值或取值

属性	说明	EL	类型	缺省
begin	开始下标	可以	int	0
end	结束下标	可以	int	最后一个成员的索引
step	步长	can	int	1
var	给当前的成员赋名称	not	String
items	循环变量	not	map\ArrayList\数组
varStatus	当前循环变量的状态	not	String

varStatus有如下几个属性

属性	说明	default
count	当前参与循环的个数	从1开始
index	循环变量的索引值	从0开始
first	第一个	boolean
last	最后一个	boolean

8、forTokens 标签 与foreach相同，用于将某个用分割符的字符串分割成若干个变量

属性	说明	EL	必须	缺省
items	进行迭代处理的变量	可以	是
delims	分隔符	can	是
begin	开始下标	can	not	0
end	结束下标	can	not	最后一个成员的索引
step	步长	can	not	1
var	当前成员变量	not	not
varStatus	与foreach相同

9、import标签 用于导入某个url地址 可以传参数

属性	说明	EL	必须	缺省
url	需要导入的页面的url	can	is
context	本地应用名	can	not
charEncoding	设置导入数据的字符编码	can	not	ISO-8859-1
var	接受导入文本的变量名称	not	not
scope	var的范围	not	not	page
varReader	接受导入文本的java.io.Reader对象	not	not

参数
<c:import url="">
<c:param name="" value="" />
</c:import>

 10、redirect 重定向 可以传参数,方法同上

二、Formate标记库，国际化标记库

1、setlocal 标签
value/variant 平台/scope 范围

2、setBundle
basename 设置使用的资源文件，不需要本地化后缀和扩展名
var   把basename所标识资源付给var
scope  缺省值page 范围
!note:使用jdk 的native2ascii工具，把properties文件转换为ascii文件，可以解决properties的内容显示为乱码

3、message 配合bundle使用

三、sql和xml标记库 不推荐使用

四、funtions标记库，用于对String类型变量处理

标记库的功能是增加表现层的处理能力，简单来说就是将HTML页面的JAVA代码转移到类似JAVABEAN的类中，来减少JSP页面的JAVA代码。

标记主要有3个帮助类(帮助类就是实现某个接口的类，这样开发者可以继承这个类而不是接口，以免要把接口的每个方法都重写)——TagSupport\BodyTagSupport\SimpleTagSupport

TagSupport的执行过程如下：

BodyTagSupport的过程如下

这两个Class的区别在于，BodyTagSupport可以对body内容进行二次再修改加工，而TagSupport则不行。

几点注意：
1、在tld文件里的<taglib><tag>标签有几个属性要注意，body-content可以有4个选项：
JSP：tag间可以包含HTML、java代码；
empty：tag间不能包含任何内容；
scriptless：不能包含脚本、java代码；可以包含EL代码；
tagdependent:包内容由标记来决定；
2、Date类一直不很清楚，今天练习一下，比如输出当前时间：
SimplyDateFormate sdf=new SimplyeDateForamte(pattern);
date=new Date(long l);//至1970年1月1日00:00:00的微秒数
out.println(sdf.formate(date))

1、JSP EL起源于JSTL1.0,全名JSP Expression Language
Jsp EL  可以在jsp中使用，也可以在jstl中使用

JSP EL作用：
(1)减少jsp页面中java代码的数量；
(2)方便jsp的修改

2、Jsp EL的运算符
算术运算符：+ - * / div % mod
逻辑运算符：&& and || or ! not
关系运算符：== eq != ne > gt >= gq < lt <= le
条件运算符：a?b:c
空：empty

3、Jsp EL语法
JavaBean ${user.username} 可以级联获取对象
数组　${address[0]}
List ${address[0]}
Map  ${phone.home}

4、JSP EL内置对象
注意：在Jsp页面使用时，严格遵循大小写

(1)Jsp El的内置对象

变量名称
 说明
 
pageScope
 一个包含所有page scope范围的变量集合 (a java.util.Map)
 
requestScope
 一个包含所有request scope范围的变量集合 (a java.util.Map)
 
sessionScope
 一个包含所有session scope范围的变量集合 (a java.util.Map)
 
applicationScope
 一个包含所有application scope范围的变量集合 (a java.util.Map)
 
param
 一个包含所有请求参数的集合 (a java.util.Map)，通过每个参数对应一个String值的方式赋值
 
paramValues
 一个包含所有请求参数的集合 (a java.util.Map)，通过每个参数对应一个String数组的方式赋值
 
header
 一个包含所有请求的头信息的集合， (a java.util.Map) ,通过每个头信息对应一个String值的方式赋值
 
headerValues
 一个包含所有请求的头信息的集合 (a java.util.Map) ，通过每个头信息的值都保存在一个String数组的方式赋值
 
cookie
 一个包含所有请求的 cookie集合 (a java.util.Map)，   通过每一个cookie（javax.servlet.http.Cookie）对应一个cookie值的方式赋值
 
initParam
 一个包含所有应用程序初始化参数的集合(a java.util.Map) ，通过每个参数分别对应一个String值的方式赋值
 
pageContext
 一个javax.servlet.jsp.PageContext类的实例, 用来提供访问不同的请求数据

(2)param \paramValues 是用来获取request中的参数和参数数组
(3)header \headerValues 是用来获取http包的header 和　header数组
(4)cookie 获取cookie
(5)initParam 获取web.xml中设置的值
(6)empty 是判断内容是否为空，比如String a="" ${empty(a)} 结果是true

5、可以设定Jsp不使用Jsp EL,有两种办法
(1)<%@ page IsELIgnored="true" %>
(2)<web-app....
     <jsp-config>
       <jsp-property-groud>
            <url-pattern>*.jsp</
            <el-ignored>true</
............

<cut>

JSP 内置对象和JSP EL内置对象

今天对MVC模式有了第一次比较深入的了解，现总结如下：

这种模式的出现主要是为了解决分工问题，
View-负责显示功能，实际上主要是由Jsp承担
Model-商业逻辑，由JavaBean承担，同时负责与DataBase交互
Control-控制逻辑，比如是直接调用一个jsp去响应浏览器请求，还是实例化一个JavaBean,然后再去响应，由servlet承担

这些理解虽然很简单，甚至可能有错误，但是以此为基础，依靠实践来完善

另外了解到两种转向的使用和区别。转向是实现jsp和servlet交互的重要办法，通过request.setAtrribut和getAttribut方法，实现在两者之间的数据交互。有两种转向办法
1\request.GetRequestDispatcher(string).forward(request,response)
2\response.sendRedirect();

区别如下：

下图是两种转向实现原理，可以理解其区别

总结一下最近对JavaBean的学习

1\JavaBean的主要作用是减少web页面的java代码，有如下的特点：
(1)标准的java类
(2)无构造方法
(3)定义有private属性，只能通过get/set方法访问属性
(4)实现serializable接口
(5)可重用

几个JavaBean动作
1、<jsp:useBean />生成一个JavaBean的对象
scope属性有几个选项,我认为实际上JavaBean的对象被如下这些类的对象使用setAttribut/getAttribut方法来调用，以实现JavaBean的使用范围。
page-pageContext
request-servletRequest
session-httpSession
application-ServletContext
注意：尽量在小范围内调用JavaBean，范围越大，对系统的性能消耗越大。

2、<jsp:getProperty />   <jsp:setProperty>
得到/设置JavaBean对象的属性，注意两点：
(1)JavaBean代码中严格遵循getAttribut()\setAttribut()语法
(2)JavaBean、html form中提交元素的命名、处理Form. 的Servlet的变量命名尽量一致；

3、学习使用Common BeanUtils 组件，优点如下：
(1)用.运算符可以级联输出对象，尤其什么Map对象、数组等等
(2)临时生成一个对象类型，来设置、获取属性值，方便处理；
(3)使用ResultSetDynaClass\RowSetDynaClass对象来接收从处理数据库返回的结果，方便处理；注意RowSetDynaClass使用方式与ResultSetDynaClass相同，但是RowSetDynaClass对connection对象有依赖，一旦其close，就不能再使用。

因为项目的关系，最近一段时间又要进行性能测试的研究。但是在安装了LR9.0以后，总是在录制的Code Generation阶段，系统就死机，弄了半天也没有解决——谁要咱公司没有钱，只能玩DAOBAN呢？

无奈之中，想起了JMeter这个free 工具，以前一直有心思研究一下，终于有机会。于是今天花了一天把官方手册快速阅读一下，感觉有点失望，原因是发现JMeter这工具好像不能使用编程方式开发脚本。当然我还没有完全掌握JMETER，现在下结论为时尚早，但是在user Manual里的确没有说可以对脚本编程。
有人把不用编程开发测试脚本，而可以使用drag and click 方式编辑测试脚本称为测试工具的优点，这点我实在难以认同。因为被测试系统的业务逻辑如果复杂，那么脚本的逻辑必然也复杂，事实证明，这个世界上没有什么比编程语言更便于解决复杂的逻辑问题，像LR的参数化，几种不同的选择方式，如果要用代码来写，我想适用性会更好。

再者，我一直认同一种观点——对于软件工具要掌握核心，而不是牢记某个软件的某个功能在哪个菜单或对话框里，所以采用编程方式更适于记忆，因为只要我理解了软件工具的核心思想，就可以很方便地开发出所需要的脚本来。

现在在JMETER和LR中做出选择还为时尚早，等今晚下个LR9.1安装以后再说吧

最近几天终于真正开始JSP，当然了，JSP的实质就是servlet。现总结一下这几天的成绩。
1、JSP的起源和作用
照目前的了解，应该是使用servlet来展现web页面太困难，因此才推出JSP技术，就是html中嵌套java代码。

2、JSP的实质——servlet,服务器端接到请求后将JSP转化为servlet再执行。

3、JSP语法：
(1)注释方法:
(2)指令:page\include\taglib
page指令的属性：pageEncoding\contextType\import\isErrorPage\ErrorPage\
(3)Declaration 标记 <%! int i=0; %>
   scriptlet 标记   <%  int i=0; %>
Declaration 中的i是全局变量，在整个session周期中值都被保存，而scriptlet中的i每次访问该JSP页面是都会重新生成；
   Expression <%=statment%>
(4)Action
   <jsp:include>和include指令区别在于：include指令使用了out.print()方法输出了文件内容，而<jsp:include>使用了JspRuntimeLibary.include()方法；
   <jsp:forward>转向，但是会导致该动作以后的代码不被执行
   等等
(5)jsp内置对象
out javax.servlet.jsp.jspwriter
request javax.servlet.servletRequest
reponse javax.servlet.servletReponse
session javax.servlet.http.httpsession
appliacation javax.servlet.servletContext
config
page
exception

4、通过web.xml来修改错误页面指向
<error-page>
  <error-code></error-code>
  <location></location>
</error-page>

今天主要研究如何进行session开发，发现一个非常有意思的现象。

在开发一个用于电子购物网站的实例中，先编写一个类，叫BuyList吧，相当于一个购物单，中间有这样一段代码
  HttpSession session=request.getSession();
  BuyList list=(BuyList)session.getAttribute("list");
  
  if(list==null){
   list=new BuyList();
   session.setAttribute("list",list);   
  }
  list.addList(new Weapon(name,id,1,price));

以上代码是在session中setAttribute一个叫“list”的key,它是一个对象，实际上应该是指向一个对象的地址。

然后代码转到另一个servlet，用来显示购物单的内容，中间又有一段代码

  HttpSession session=request.getSession();
  BuyList list=(BuyList)session.getAttribute("list");
  
  ArrayList<Weapon> weaponlist=list.getList();

看，这个list居然在另外一个class文件中神奇地复活，注意它是不是公共变量，但是通过session.getAttribut()/setAttribut(),把BuyedList类的实例的地址放在这个Attribut中，就可以通过session随时得到这个BuyedList的实例，这多么有趣。我想这也许就是session类似cookie的地方，只是在服务器端而已。

今天主要学习以下内容：

1、尝试在tomcat中修改context.xml文件，然后通过读取这个文件来得到connection，但是在实践操作过程中失败了
***********************************************************

Context context=new InitialContext();
  DataSource ds=(DataSource)context.lookup("java:/comp/env/jdbc/oracleds");
  conn=ds.getConnection();
  PreparedStatement prstm=conn.prepareStatement(sql);

************************************************************

红色部分总是报错，返回一个空的conn对象。通过debug查看，但是因为部分的类不能看到源代码，所以不知道错在哪里？

虽然没有结果，但还有一个收获。就是原来tomcat是不包含ＪＤＢＣ的ＪＡＲ包的，在MyEclipse中比如手动引入jar包。

最后决定放弃，因为我现在对MyEclipse的debug　view还不熟悉，调试中有很多疑问不能理解，因此下一步的学习方向调整为熟悉MyEclipse

2、今天学习的第二个内容是DButils组件。这个组件我感觉有以下几个好处：
(1)以前通过自己写ＪＤＢＣ只能在connection没有close直接获取数据，但是通过这个组件可以返回数据库记录为map 或javabean，然后可以方便地操作数据——即使connection关闭了。
(2)操作数据方便，不用考虑什么时候close connection.

明天学习任务为熟悉MyEclipse

前一段时间本打算用1个月的时间攻克jsp和servlet，但是今天才意识，要花的时间可能要比我想的多一些。

是什么使我产生这种想法改变呢？
一个是进度没有我预期的顺利，本以为在JAVA和C#方面已经掌握的情况下攻克JSP不是太大的问题，但是因为对ECLIPSE工具的不熟悉，对TOMCAT的不熟悉等等原因，看资料觉得很懂，但是一动手就漏洞百出，感觉整个思维还没有完全理解servlet的本质。即时能按教程做出实例，但是还是遗留很多疑问，而解决这些疑问需要时间来搜索资料、思考问题。

二个是感觉学习只是生活的一部分，长时间地看电脑觉得眼睛和手都有不适感，而且学习效率也大打折扣。昨天晚上睡觉时思考一个问题，学习目的是什么？不应该是更好地生活吗？不应该是更好地理解生活的本质吗？但是身体也是生活的一部分，属于生活的外在部分，而学习是提炼自己，属于生活的内在部分。中国人追求和谐、平衡，我应该调整自己的生活方式，保持内在和外在的平衡。

三个是我相信事务的进展应该是一个循序渐进、厚积薄发的过程，回顾自己从html\javascripts\java\pl/sql\c#的学习过程，去年还对很多问题不理解，可是突然之间好多问题再想想都理解，似乎冥冥之中有个顿悟的过程，但是这个顿悟不是凭空等来的，而是随着知识的积累发酵而成。

我对下阶段的想法是：
1、在3月底完成JSP和servlet的学习；
2、在掌握基础JSP编程后，可以考虑中途加入学习TOMCAT的内容，毕竟对应用服务器的熟悉也很重要。
3、现在还是按每天一个章节的进度, 争取本周到第8章。
4、当遇到不理解的问题是，不要立刻中断现有学习，去研究遇到的问题，而应该进行判断：如果这个问题不理解就不能进行下一步，就研究问题；如果可以继续进行，先把这个问题记录下来，等现有学习结束后，再进行研究。-这种处理很重要