2014年暑假学习笔记

2014-7-3
System.getProperty("user.dir") 用户的当前工作目录

QPS每秒查询率(Query Per Second)
每秒查询率QPS是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准，在因特网上，作为域名系统服务器的机器的性能经常用每秒查询率来衡量。
对应fetches/sec，即每秒的响应请求数，也即是最大吞吐能力。

般来说 java file.delete失败 有以下几个原因
1.看看是否被别的进程引用，手工删除试试
2.file是文件夹 并且不为空，有别的文件夹或文件，
注意： 3.极有可能有可能自己前面没有关闭此文件的流

W3C 指 World Wide Web Consortium，万维网联盟。
WHATWG 指 Web Hypertext Application Technology Working Group。

 

2014-7-7
我在学习Java的过程中主要围绕以下几个方面来学习：

1．时刻提醒自己Java是一种OOP语言工具，而不仅仅是编码，只有这样才能总体把握和运用Java。

2．在学习的过程中，最好能够了解Java的底层机制，而不是仅仅停留在表层，不是抄书上的例子运行出结果就可以。要注意，即便对一个简单的例子也要有耐心去琢磨、调试、改动。

3．在学习的过程中一定要动手做、写代码，而不是抱一本书看看就行。很多东西和体会必须自己动手才能真正属于自己，最好能参与一些实际的项目。

4．在学到一定阶段后，你开始希望用学过的东西做些什么。这时的你应该开始学习一些更多、更复杂的知识，比如J2EE平台的构建、EJB的开发等。对于这一部分，我建议最好找一本较薄的书先了解一个大概，心里有个总体的认识，对更多的技术术语做个初步掌握。我认为这个阶段看看《J2EE技术实践》很不错，它可以让你了解J2EE包含的各种技术和框架，同时提供很多实际的例子来加深对J2EE的整体了解。

在有一定基础、能够写一些简单的程序后，可以开始看《Thinking in Java》这本书。它比较完整地介绍了Java的语法、面向对象的特性、核心类库等。通过这一层次的学习能够加深对Java的理解和底层原理的运用，同时又可以完整地了解Java的整个体系。在这一阶段，应该重点学习Java的面向对象编程语言的特性，比如继承、构造器、抽象类、接口、方法的多态、重载、覆盖、Java的异常处理机制等，要对上述概念有非常清楚的了解。这样做的目的，是要让自己把这些技术应用到实践中进行合理的程序设计（比如，你会考虑一个类是用抽象还是接口来设计等）。

 

JAVAWEB开发所需
那么，建立一个比较完整的WEB工程，并且跑起来（完成从前台到数据库的完整处理流程，哪怕只是插入一个整数），需要一个什么样的知识集合呢？

1、首先是环境准备。

通常，我们需要开发工具：Eclipse，或者MyEclipse。但我从来没有用过，我选Eclipse。
然后，选择WEB容器，最常用的Tomcat，或者Jetty，JBoss亦可。我选Tomcat。

2、选择数据库。

没有数据库，很难做出有价值的应用，所以，我们需要选择一个数据库，
自己研究，用的最多的是MySql，当然，Oracle，Postgres也很常见，
喜欢Sql Server的也不少，不过我已经N年没有玩过了。
我选MySql。

3、建立工程。

我相信很多人根本没有自己手工创建过WEB工程的目录结构，都是使用工具自动生成，我坚信，了解工具帮助我们干的事情非常必要，而且非常有好处的。这里主要是建立WEB-INF目录，WEB-INF/classes，WEB-INF/lib，创建初始的 web.xml。

4、写代码前的准备工作

在真正开始写第一行代码之前，我们还需要做的准备工作有：
> 配置日志系统，java领域最常用的 Log4J
> 选择连接池，我用了C3P0
> 选择持久化技术。当然，直接使用JDBC也可以，不过现在多数项目还是用持久化层的，Hibernate 和 Ibatis，处于简单性考虑，选择 Ibatis。

当然，这些准备工作，除了技术选型的决策，还都涉及到寻找相应的 jar 包、 jar 包所依赖的 jar，以及写编写初始的配置文件，包括：log4j.properties，c3p0.properties 和 ibatis 的一系列配置。据我所知，不了解 log4j.properties 配置项含义，只会拿来例子就用的绝不在少数，还有很多人，在将 web 工程发布到 tomat 以后，无法把 log4j.properties 配置与实际的日志文件所在的位置对应起来。

5、写代码测试配置，并验证不熟悉的技术（比如 ibatis，我第 0.2 次用，N 年前了解过）

这个过程耗时较长，尤其是 ibatis ，官方的文档并不丰富，使用它做到对数据库表的增、删、改、查，调了一个下午的时间，最后发现，ibatis 出到了 3.0，但其配套工具ibator （用于自动从数据库生成表对应的 javabean 和 sql 映射文件）生成的配置文件语法完全不对，仔细一看，ibator 的最后更新时间 2008年，faint！

6、开始写工作代码

这时候就更体现了 Java 大家庭的繁荣，以及程序员的兼容并蓄了。

首先，会 Java，Jsp 那是肯定的。

而框架方面呢，我一直不待见 SSH，因此还是准备只用 Struts，这样可以不学强大的有点过于强大的Spring。
还有些技术点，要么是必然用到的，要么是很好用的，包括：
> XML处理，或者 JSON 二选一，现在 JSON 大有取代 XML 的趋势。
> Apache commons 系列的类库，尤其BeanUtils，StringUtils，API 多少了解一点还是很有好处的。
> JSTL，我一直很想为这项技术鸣不平，我觉得挺好的东西，但我周围的人都很冷落它。

然后，因为项目需要，我还要使用一些特定的技术：
> WEB Service技术，我用 Restful 模式，在Restlet 和 Jersey 之间选择，最后用了 Restlet。
> 需要做一些图表，选用 JFreeChart
> … 其实还有很多，不一一列举了

7、工程打包、发布

日常工作中，工程的集成、打包和发布，通常不是程序员需要关心的问题。但如果是你一个人在战斗，除了会在 MyEclipse 的帮助下集成 Tomcat 进行测试，最好掌握一种手段，把工程打包发布到独立的 Tomcat 下，从而避免繁琐的手工操作。

常见的方式有：
> ant
> maven

原来我用 ant，不过现在转投 maven 了，用熟了以后，感觉 maven 比 ant 要好很多，不过，ant 的价值在于灵活，有时候用于完成一些非标工作挺实用的，比如：增量拷贝文件等等。

如果再提稍微高一点的需求，那就是最好掌握 windows 下批处理文件和 linux 下 shell 脚本的编写。

8、版本控制

为了协作、分享或者是安全起见，保存代码的历史版本很重要，
因此需要选择版本管理工具，SubVersion 和 CVS 都很好，
不过我用 CVS 更熟练一些。

---

因此，做一个合格的 JAVA WEB 开发人员，真的是不大容易。
知识面要宽，学习能力要强，要善于触类旁通。

对了，我还忘了说前台相关的技术，那就是 javascript，CSS，ajax，有时候，还得搭上Flash，及JQuery等一系列的框架。

 

2014-7-8
DAO(Data Access Object)数据访问对象，每个DAO组件都提供Domain Object对象基本的创建，查询，删除，更新等操作，这些操作对应于数据表的CRUD等原子操作。
DTO(Data Transfer Object)数据传输对象，也叫JavaBean集

表现层技术：JSP FreeMarker Velocity
ORM(Object relation mapping)

Spring更像是以后总中间容器，向上可以与MVC框架无缝整合，向下可以与各种持久层框架无缝整合，具有强大的生命力。

企业应用开发的两个关注点：可维护性和复用

JNDI(JAVA Naming Directory Interface)Java命名和目录接口，就是为某个Java对象起一个名字，从而让其他程序可以通过这个名字访问数据源对象                                                                               
JSP的基本原理：JSP本质上是Servlet，当用户向指定Servlet发送请求时，Servlet利用输出流动态生成HTML页面。
JSP页面包括两部分：
1.静态部分：标准的HTML标签，静态页面内容
2.动态部分:受Java程序控制的内容，由Java程序动态生成                                                                                           

 JSP注释<%-- 注释内容 --%>
HTML注释<!-- 注释内容-->                                                                                                                    

JSP声明<%! 声明部分 %>
例：<%!
public int count;
public String info(){
 return "hello";
}

%>                                                                                                                                         

 可以使用public static private修饰，但不能用abstract，因为抽象方法会将JSP对应的Servlet变成抽象类，从而导致对象无法例化。                                                                                             

 JSP输出表达式：<%= 表达式%> 代替了原来的out.println语句                

 例：<%= count++%> <%=info()%>                                         

注意表达式语法后不能有分号。

JSP三个编译指令，是通知Servlet引擎的处理消息，在将JSP编译成Servlet时起作用
page:针对当前页面的指令
include：用于指定包含另一个页面
taglib：用于定义和访问自定义标签

JSP的7个动作指令，只是运行时的动作，通常可以替换成JSP脚本，只是JSP脚本的标准化写法
1.jsp:forward:执行页面转向，将请求的处理转发到下一个页面
2.jsp:param:用语参数传递，必须与其他支持参数的标签一起使用
3.jsp:include:用语动态引入一个JSP页面
4.jsp:plugin:用于下载JavaBean或Applet到客户端执行（略过）
5.jsp:useBean:创建一个JavaBean的实例
6.jsp:setProperty:设置javaBean实例的属性值
7.jsp:getProperty:输出javaBean实例的属性值

静态导入与动态导入（include）的三点区别：
1.静态导入是将被导入页面的代码完全融入，两个页面融合成一个整体Servlet,而动态导入则在Servlet中使用include方法来引入被导入的页面内容
2.静态导入时被导入页面的编译指令会失去作用，而动态导入时被导入页面的编译指令会失去作用，只是插入被导入页面的body内容
3.动态包含还可以增加额外的参数

forward指令使用_jspx_page_context的forward()方法来引入目标页面
include指令是使用JspRuntimeLibrary的include（）方法来引入目标页面，区别在于执行forward时，被forward的页面将完全代替原有页面，而执行include时，被include的页面只是插入原有页面。

JSP脚本中的9个内置对象，都是Servlet API接口的实例，已经是对象，可直接使用。
1.application
每个web应用只有一个ServletContext实例，在JSP页面中可以通过application内置对象访问该实例，而Servlet中需要通过如下代码获取：
ServletContext sc = getServletConfig().getServletContext();          

通常只把web应用的状态数据放入application中
还可以获取web应用配置参数,必须先在web.xml内配置
<context-param>
 <param-name>...</param-name>
 <param-value>...</param-value>
</context-param>
再通过application.getInitParameter(String paramName)获取，这样的方式将一些配置信息放在web.xml中，避免硬编码方式写在代码中，从而提高程序的移植性。

2.config
config.getInitParameter(String paramName)获取web.xml中servlet的配置信息
3.exception
JSP无需处理异常，因为脚本已经在try,catch块中
处理：如果页面的page指令指定了errorPage属性，则将请求forward到errorPage属性指定的页面，否则使用系统页面输出异常信息。
4.out
out是JspWriter的实例，JspWriter是Writer的子类，是字符流，无法输出非字符内容，如位图，PDF文档等，可以使用response作为响应输出
<%= ...%>的本质就是out.write()
5.page
6.pageContent
代表页面上下文，主要用于访问jsp之间的共享数据，可访问page,request,session,application范围的变量（1，2，3，4表示对应生存范围）
7.request
每一个request对象都封装着一次用户请求，并且用户请求参数都被封装在request对象中，request对象是获取请求参数的重要途径
forward用户请求时，请求参数和request范围的属性都不会丢失，即forward动作还是原来的请求，并未再次向服务器发送请求。
                                        
request还可以执行forward和include,HttpServletRequest提供了一个getRequestDispatcher（String path）方法,path必须以“/”开头
如下代码：
getRequestDispatcher("/a.jsp").include(request,response);将a.jsp页面include到本页面中
getRequestDispatcher("/a.jsp").include(request,response);将请求forward到a.jsp页面

8.response
代表服务器对客户端的响应，1.可以输出非字符内容，response.getOutputStream()
2.重定向请求，与forward不同的是，重定向会丢失所有的请求参数和request的范围属性，因为重定向将生成第二次请求，与前一次请求不在同一个request范围内，所以发送一份请求的请求参数和request范围的属性全部丢失。
response.sendRedirect(String path),用于重定向到path资源，即重新向path资源发送请求。相当于在地址栏重新输入新地址按回车键，即发送第二次请求。

3.用语向客户端增加Cookie
步骤：
1.创建Cookie实例，Cookie的构造器为Cookie(String name, String value)
2.设置Cookie的生命期限
3.向客户端写Cookie
代码：
String name = request.getParameter("name");
Cookie c = new Cookie("username",name);
c.setMaxAge(24*3600);//24小时
response.addCookie(c);
出现中文的时候借助于java.net.URLEncoder先对中文字符进行编码，然后设为Cookie的值，读取Cookie时，先读取，在使用java.net.URLDecoder进行解码。

9.session

非常常用的对象，代表一次用户会话，从客户端浏览器链接服务器开始到客户端浏览器与服务器断开为止，这么个过程。
用途：通常用语跟踪用户的会话信息，如判断用户是否登录系统，或者在购物车应用中用语跟踪用户购买的商品。
session范围内的属性可以在多个页面的跳转之间共享，一旦关闭浏览器，即session结束，session范围内的属性将全部丢失。

两个常用的方法：setAttribute（String attName, Object attValue）
getAttribute(String attName)
JSP内置对象的实质：要么是_jspService()方法的形参，要么是它的局部变量，所以在JSP脚本中直接调用这些对象，无须创建他们。                                                                                                 
name相同时，获取代码：
String[] buys = request.getParameterValues("item');

 2014-7-9

Servlet通常被称为服务器端的小程序，用于处理及响应客户端的请求。
Servlet与JSP的区别：
Servlet没有内置对象，原来JSP中的内置对象必须由程序显示创建。
对于静态的HTML标签，Servlet都必须使用页面输出流逐行输出。                                                                                     

 创建Servlet的两个时机：
1.客户端第一次请求，系统创建该Servlet实例
2.Web应用启动时立即创建Servlet实例，即load-on-startup Servlet
配置方法：在<servlet>的子元素<load-on-startup>1（数字越小，优先级越高）</load-on-startup>
                 
ServletConfig获取配置参数的方法：
ServletConfig config = getServletConfig();
config.getInitParameter("")                                          

 ServletConfig是获取当前Servlet的配置参数，而ServletContext是获取整个Web应用的配置参数                                                        
在标准的MVC模式中，Servlet仅作为控制器（Controller）使用，JSP作为表现层技术（负责手机用户请求参数，将应用的处理结果、状态数据呈现给用户）,Model由JavaBean充当，所有业务逻辑，数据访问逻辑在Model中实现。
TLD（tag library definition）标签库定义，文件后缀是tld

 Filter的使用流程：Filter对用户请求进行预处理，接着将请求交给Servlet进行处理并生成响应，最后Filter再对服务器响应进行后处理。
创建Filter步骤：
1.创建Filter处理类
2.web.xml文件中配置Filter                                                                     

使用URL Rewrite实现网站伪静态--> html
实现HttpSessionListener接口的监听器可以监听系统的在线用户
                                                                    关于Map的keySet与entrySet                                             
01 据说keyset 比 entrySet 效率低.
02 
03  Map<String,String> valueMap = new HashMap<String,String>
04  for(String valName :valueMap.keySet())
05         {
06             String key =valName;
07             Object value = valueMap.get(valName);      
08  }
09 
10  Set<Map.Entry<String, String>> keyEntrySet = valueMap.entrySet();
11     for(Map.Entry<String, String> entry:keyEntrySet)
12     {
13         String key = entry.getKey();
14         Object value = entry.getValue();
15        
16    }
17 Map<String,String> questionsMap= new HashMap<String,String>
18 Iterator<Entry<String,String>> questions = questionsMap.entrySet().iterator();
19  while (questions.hasNext()) {
20  Entry<String, String> question = questions.next();
21  question.getValue()
22 question.getKey()
23                      
24 }                                                                                                                                                                                                                                                                             

  表达式（Expression Language)--EL
语法格式：${ expression }
支持算术与逻辑运算符，在页面上正常输出$，需要用“\”转义
逻辑运算符（&gt &lt 等）
11个内置对象
pageContext,pageScope,requestScope,sessionScope,application
param,paramValues（数组）,header,headerValues(数组),initParam,cookie

implicit
adj.不言明[含蓄]的; 无疑问的，绝对的; 成为一部份的; 内含的;

如果需要在EL中进行更复杂的 处理就可以通过函数来完成，函数的本质：提供一种语法允许在EL中调用某个类的静态方法

对字符串进行反转
public String reverse(String text){
 return new StringBuffer(text).reverse().toString();
}
                                                                     

Servlet3.0提供异步处理，通过AsyncContext类
提供Annotation，无需配置web.xml，使用@WebServlet等配置
Servlet3.0支持使用注解配置Servlet。我们只需在Servlet对应的类上使用@WebServlet进行标注，我们就可以访问到该Servlet了，而不需要再在web.xml文件中进行配置。@WebServlet的urlPatterns 和value属性都可以用来表示Servlet的部署路径，它们都是对应的一个数组。
对于Servlet上传时保存文件名，实际开发中可能多个用户填写相同name，导致上传的内容会覆盖之前的，实际项目中可以借助java.util.UUID工具类生成文件名

UUID(Universally Unique Identifier)全局唯一标识符,是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的。                                                                                                                                                                   Struts2
OGNL（Object-Graph Navigation Language），可以方便地操作对象属性的开源表达式语言，使页面更简洁；
支持运算符（如+-*/），比普通的标志具有更高的自由度和更强的功能；
Struts 2默认的表达式语言是OGNL                                                                                                              

Struts2框架按如下搜索顺序加载Struts2的常量：
struts-default.xml
struts-plugin.xml
struts.xml（整个Struts2框架的核心）
struts.properties
web.xml
如果多个文件中配置了同一个常量，后一个会覆盖前面的。                                                                                                                                                                

在默认情况下，Struts2 只自动加载类加载路径下的struts.xml,default-struts.xml,和struts-plugin.xml三个类文件。但随着应用规模增大，系统中的Action数量也大大增加，导致struts.xml配置文件变得臃肿，所以可将其分解成多个配置文件，然后在struts.xml文件中包含其他配置文件，使用include标签，这样能以模块化的方式管理struts.xml配置文件。                                                                                                      

POJO（Plain Old Java Object）简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。                                        

使用POJO名称是为了避免和EJB混淆起来, 而且简称比较直接. 其中有一些属性及其getter setter方法的类,没有业务逻辑，有时可以作为VO(value -object)或dto(Data Transform Object)来使用.当然,如果你有一个简单的运算属性也是可以的,但不允许有业务方法,也不能携带有connection之类的方法。

Action类默认处理用户请求的逻辑控制方法：execute方法

 

2014-7-10
配置Action
Struts2框架中的核心组件就是Action,拦截器等，Struts2使用包来管理Action和拦截器等，每个包就是多个Action,,多个拦截器，多个拦截器引用的集合。      
配置<package../>元素时必须指定name属性，该属性是引用该包的唯一标识                                                                            

Struts2以命名空间(namespace)的方式来管理Action,同一个命名空间里不能有同名的Action,不同的命名空间里可以有同名的Action
当某个包指定了命名空间后，该包下所有的Action处理的URL应该是命名空间+Action名

<action.. class=""/>设置class属性，指定该Action的实现类，如果不指定，系统则默认使用ActionSupport类

DMI(Dynamic Method Invocation)动态方法调用
action="ActionName!methodName",其中，ActionName指定提交到哪个Action,而methodName指定提交到指定方法

<form action="login" method="post">                                  

function regist()
{
 //获取页面的第一个表单
 targetForm = document.forms[0];
 //动态修改表单的action属性
 targetForm.action = "login!regist";
}                                                                                                                                                                                                                

配置Action实际上可以认为三个属性需要配置：
1.name指定Action处理怎样的请求，不可省略
2.class属性指定该Action的处理类，可省略，默认使用ActionSupport作为处理类
3.method属性指定使用哪个方法处理请求，可省略，默认使用execute方法

使用通配符
<action name="*Action" class="...LoginRegistAction" method="{1}">
<action name="*_*" class="...actions.{1}" method="{2}">               Struts2不尽允许在class属性，name属性中使用表达式，可以在<result../>子元素中使用｛N｝表达式

当用户请求的URL同时匹配到多个Action时，完全匹配则由该Action处理，匹配不到时，从上往往下，先找到哪个Action就会由哪个处理。                        

当用户请求找不到对应的Action，可通过配置默认Action处理用户请求
<default-action-ref name=".."/>
<action name=".." class="">
</action>                                                                                                                                  

Action处理完用户请求后，并未直接将请求转发给任何具体的视图资源，而是返回一个逻辑视图（通常只是一个普通的字符串--逻辑视图名），Struts2框架收到这个逻辑是图后，把请求转发到对应的视图资源，视图资源将处理结果呈现给用户。

result默认type是dispatcher
redirect是将请求重定向到指定的视图资源，丢失所有请求参数，属性，和Action的处理结果
dispatcher结果类型是将请求forward（转发）到指定的JSP资源

当需要让一个Action处理结束后，直接将请求重定向到另一个Action，要使用type = "redirectAction"                                                                                                                                                                                              

  2014-7-11

对于我这样的研一还没有发论文的人来说，我的暑期注定要和孤独为伴，哪怕大家都在一个实验室里搞科研，但是依然各自行色匆匆，埋头苦读文献，默默搞科研。不是冷漠，而是每个人真正强大起来前，都要度过一段没有人帮忙，没有人支持的日子。所有事情都是自已一个人扛，所有情绪都是只有自己知道。但是只要咬牙撑过去，一切都不一样了。无论你是谁，无论你在经历什么，坚持住，你定会看见最坚强的自己！为各自忙碌的我们点赞吧！--Kevin

struts2访问servletAPI的三种方法

1.使用ServletActionContext访问：
HttpServletRequest request = ServletActionContext.getRequest();
HttpSession session = request.getSession();
HttpServletResponse response = ServletActionContext.getResponse();
PageContext pageContext = ServletActionContext.getPageContext();                                                                          

  2.使用ActionContext访问：
Map<String, Object> session = ActionContext.getContext().getSession();                                                                                                                                        

3.实现SessionAware, ServletRequestAware, ServletResponseAware接口，并重写相应的方法，代码有点繁多：                                         

public class MyAction2 implements SessionAware, ServletRequestAware, ServletResponseAware{

private HttpServletRequest request;
private HttpServletResponse response;
private Map<String, Object> session;

public String login(){
return "success";
}

public void setServletResponse(HttpServletResponse response) {
this.response = response;

}

public void setServletRequest(HttpServletRequest request) {
this.request = request;

}

public void setSession(Map<String, Object> session) {
this.session = session;

}

}                                                                                                                                                                                                                

 

Action处理用户请求后会返回一个字符串作为逻辑视图，该逻辑视图必须映射到实际的物理视图才有意义。Convention默认也会为作为逻辑视图和物理视图之间的映射提供了约定。默认情况下，Convention总会到Web应用的WEB-INF/content路径下定位物理资源，定位资源的约定是:actionName+resultcode+suffix。当某个逻辑视图找不到对应的视图资源时，Convention会自动试图使用actionName+suffix作为物理视图资源。                                                      

 suffix 后缀  prefix前缀

 

Struts2提供了Config Browser插件，可以看到Struts2应用中Action等各种资源的映射情况以及每个Action详细的映射信息，更有利于开发者调试。

实现Convention插件的自动重加载映射
既可以在web.xml也可以在struts.xml 或者struts.properties文件中配置
<constant name="struts.devMode" value="true"/>
<constant name="struts.convention.classes.reload" value="true" />                                     
Convenion插件主要致力于解决Action管理，Result管理等最常见，也最琐碎的配置。                                                                  

 Struts2的Convention插件主要集中在管理Action和Result映射之上，而Struts2还需要管理拦截器，异常处理等相关信息，使用Annotation来管理，除此之外，Convention还允许使用Annotation管理Action和Result的配置，从而覆盖Convention的约定。

对于包含西欧字符的国际化资源文件必须使用native2ascii工具进行处理，然后重命名。                                                                                                                                      

Struts2标签库分为以下三类
1.UI（User Interface）用户界面标签：主要用于生成HTML元素的标签
1.1表单标签，主要用于生成HTML页面的form元素，以及普通表单元素的标签
1.2非表单标签，主要用于生成页面上的树，tab页等标签

2.非UI标签：主要用于数据访问，逻辑控制等的标签
2.1流程控制标签，主要包含用于实现分支，循环等流程控制的标签
2.2数据访问标签，主要包含用于输出ValueStack中的值，完成国际化等功能的标签

3.Ajax标签：用于Ajax支持的标签 
                                                                                                                                           
OGNL的Stack Context与Value Stack
Stack Context 是整个OGNL计算求值的Context
Value Stack只是Stack Context内的“根”对象而已                          OGNL的Stack Context除了包括Value Stack这个根之外，还包括parameters,request,session,application,attr等命名对象，但这些对象都不是根。
Stack Context“根”对象和普通命名对象的区别在于：
1.访问Stack Context里的命名对象需要在对象名之前加“#”
2.当访问OGNL的Stack Context"根"对象的属性时，可以省略对象名                                                                                   

OGNL提供两个运算符：in和not in
代码：
<s:if test=" 'foo' in {‘foo’,'bar'}">
包含
</s:if>                                                              
允许通过规则取出集合的子集：
1.？： 取出所有符合选择逻辑的元素
2.^: 取出符合选择逻辑的第一个元素
3.$: 取出符合选择逻辑的最后一个元素
代码：
person.relatives.{? #this.gender == 'male'}
#this表示集合里的元素 代码意思：取出person的所有性别为male的relatives的集合

2014-7-12
Struts2很多标签可以指定var属性，一旦指定，则会将新生成，新设置的值放入Stack Content中，必须以#name形式访问，如果不指定，新生成，新设置的值位于ValueStack中，可以直接访问

push标签用于将一个值放到ValueStack的栈顶，从而可以更简单的访问该值
其中value为必须属性，指定需要放到ValueStack栈顶的值

set标签用于将某个值放入制定范围，set标签的使用可以理解为定义一个新变量，且将已有的值复制给新变量，并且可以将新变量放到指定范围（application，session等）
有如下属性：
scope：指定范围（application，session，request，page,action（默认））
value：指定将赋给变量的值
如果指定action范围，则该值将被放入request范围中，并被放入OGNL的Stack Context中
取值：requestScope.xxx.name、applicationScope.xxx.name、sessionScope.xxx.name

property标签作用就是用于输出value指定值,如果没有指定value，默认输出Value Stack栈顶的值

学姐的笑话：
上来一小伙子，听口音是河南人，聊了几句就聊到感情，小伙子感受特深，说起了他以前处的对象，是河南的，家里人非常反对。我有点疑惑：本地人不是挺好的吗？家里离的也很近。 他说，不是，他对象是东北的。刚刚不是说河南的?

 
2014-7-13
感动的 touched/moved                                                  
为了让Struts2能了解集合属性中的元素类型，可以使用一下两种方式：
1.通过为集合属性指定泛型
2.通过在Action的局部类型转换文件中指定集合元素类型（参考李刚书P280）

输入校验分为客户端校验和服务器校验，客户端校验主要是过滤正常用户的误操作，对于恶意用户的恶意行为，客户端校验也无能为力，主要通过JavaScript代码完成，从而降低服务器的负载，服务器端校验是整个应用阻止非法数据的最后防线，主要通过在应用中编程实现。

<field-validator type="requiredstring"> --字符串验证
   <param name="trim">true</param> --去空格

   <message>用户名不能为空！</message>
</field-validator>

<s:fielderror/>标签输出错误信息提示
 

客户端校验的两个步骤：
1.将输入页面的表单元素改为使用Struts2标签生成表单
2.为<s:form/>元素增加validation="true"属性

客户端校验仅支持以下集中校验器：
required validator(必填)、requiredstring validator、
stringlength validator、regex validator（表达式校验器）、
email validator、int validator、url validator、double validator

客户端校验三个注意的地方：
1.<s:form/>元素有一个theme属性，不要将其设置为simple
2.浏览者不能直接访问启用客户端校验的表单页，这样会引起异常，可以将此表单页放在WEB-INF路径下，让浏览者访问所有资源之前都先经过Filter
3.启用客户端校验的表单页面的action和namespace要分开写，如：
<s:form action="registPro" namespace="/lee">

提示：一旦使用MVC模式，就应该严格遵守MVC思想，尽量避免浏览者可以直接访问Web应用的视图页面，而是应该让浏览者向控制器发送请求，由控制器调用视图页面向浏览者呈现数据。

Struts2搜索规则是从上而下的，实际用的校验规则是所有校验规则的总和。如果两个校验文件中指定的校验规则冲突，则后面文件中的校验规则取胜。

短路校验器:校验规则文件的<validator .../>和<field-validator .../>元素可以指定一个可选的short-circuit属性，默认false
如果使用客户端短路校验，修改表单页的s:form标签增加 validate="true"，第一个表单域校验失败时将导致系统不会校验其他表单域。

2014-7-14
2014巴西世界杯，德国阿根廷决赛，买了八注彩票没中奖
lottery n. 彩票；碰运气的事，难算计的事；抽彩给奖法
保持一颗平常心
keep the heart usual
treat life calm-minded
be as flexible as possible and try to be satisfied with whatever happens next.

如果Struts2系统在WEB-INF/classes路径下找到一个validators.xml文件，则不会加载系统默认的default.xml文件。因此，如果开发者提供了自己的校验器注册文件，一定要把default.xml文件的稳步内容复制到validator.xml中。

<s:fielderror/>标签专门负责输出系统的FieldError信息，也就是输出系统的类型转换失败提示和输入校验的失败提示。

不管用户向Action的哪个方法发送请求，Action内的validate()方法都会被调用，如果该Action内还有该方法对应的validateXxx()方法，则该方法会在validate方法之前被调用。如果重写validate（）或者validateXxx()方法进行校验时，如果开发者在这两个方法中添加FieldError，但Struts2的表单标签不会自动显示这些FieldError提示，必须使用<s：fielderror/>标签来显示输出错误提示。

Struts2的输入校验的几个步骤：
1.类型转换器负责对字符串的请求参数执行类型转换，并将这些值设置成Action的属性值
2.在执行类型转换过程中可能出现异常，如果出现异常，将异常信息保存到ActionContext中，conversionError拦截器负责将其封装到FieldError里，然后执行第3步，如果转换过程没有异常信息，则直接进入第3步
3.使用Struts2应用中所配置的校验器进行输入校验
4.通过反射调用validateXxx()方法，其中Xxx是即将处理用户请求的处理逻辑所对应的方法
5.调用Action类里的validate（）方法
6.如果经过上面5个步都没有出现FieldError，将调用Action里处理用户请求的处理方法，如果出现FieldError，系统将转入input逻辑视图所指定的视图资源。

Struts2的文件上传
Struts2默认使用Jakarta的Commom-FileUpload的文件上传框架，需增加commons-io-1.3.2.jar和commons.fileupload-1.2.1.jar
为了完成文件上传需要在表单域中增加 enctype="multipart/form-data"
<s:file/>用于生成文件上传域

Sturts2实现文件上传的编程关键在于，使用三种属性来封装文件域：
1.类型为File的xxx属性封装了该文件域对应的文件内容
2.类型为String的xxxFileName属性封装了该文件域对应文件的文件名
3.类型为String的xxxContentType属性封装了该文件域对应文件的文件类型

拦截器实现文件过滤：过滤文件大小或内容，必须显示配置引用
Struts默认的拦截器栈，而且fileUpload拦截器必须配置在defaultStack拦截器栈之前。如下代码：
<interceptor-ref name="fileUpload">
 <param name="allowedTypes">image/png,image/gif</param>
 <param name="maximumSize">2000</param>
</interceptor-ref>
<interceptor-ref name="defaultStack"/>

文件上传的常量配置：Struts2执行上传文件时，需要指定一个临时文件夹，如果没有指定， 系统默认使用javax.servlet.context.tempdir，在Tomcat安装路径下的work\Catalina\localhost\路径下。
文件上传完成，系统会对临时文件进行删除。
为了避免使用默认临时路径，应该是指struts.multipart.saveDir属性。该属性可以通过struts.properties文件设置，也可以通过struts.xml文件的常量配置。除此之外，文件上传还有一个属性：struts.multipart.maxSize，该属性设置整个表单请求内容的最大字节数。

使用Struts2控制文件下载
大部分时候文件下载直接在页面上给出一个超链接，该链接的href属性等于要下载文件的文件名，这样是可以实现。但是该文件名如果是中文，则会导致下载失败。
Struts2的解决方法:FileDownloadAtion需要提供一个返回InputStream流的方法，该输入流代表被下载文件的入口。
代码：
private InputStream inputPath;
public void setInputPath(String value){
 inputPath = value;
}
public InputStream getTargetFile() throws Exception{
 return ServletActionContext.getServletContent().
 getResourceAsStream(inputPath)
}

用户下载前还应该进行下一步的检查，比如判断用户是否有足够的权限下载该文件，实现方法：在Action的execute()方法返回success字符串之前，首先判断session里的user属性，通过验证就允许下载，否则返回登录页面。
代码：
public String execute() throws Exception{
 ActionContext ctx = ActionContent.getContent();
 Map session = ctx.getSession();
 String user = (String)session.get("user");
 if(user != null && user.equals("ss")){
  return SUCCESS;
 }
 ctx.put("tip","您还未登陆或者用户名密码不对，请重新登录！");
 return LOGIN;
 
}

提示：尽量避免在Action中直接访问ServletAPI,这样会导致Action与Servlet的高耦合。

当配置一个包时，可以为其指定默认拦截器，一旦为某个包指定了默认的拦截器，如果该包中的Action没有显示指定拦截器，则默认的拦截器将会起作用，但值得注意的是如果一旦我们为该包中的Action显式应用了某个拦截器，则默认的拦截器将会不起作用；如果该Action需要使用该默认的拦截器，需要手动配置拦截器的引用。
注意:
1.只有当Action中没有显式应用拦截器时，该Action所在包的默认拦截器才会生效。
2.每个<package.../>元素只能有一个<default-interceptor-ref.../>子元素，即每个包只能指定一个默认拦截器，

<interceptor-ref../>元素中指定的属性值覆盖了在<interceptor../>元素中的属性值

使用拦截器的两个步骤：
1.通过<interceptor ../>元素来定义拦截器
2.通过<interceptor-ref ../>元素来使用拦截器

实现拦截器类：需要实现Interceptor接口
该接口中包括了intercept(ActionInvocation invocation)方法，是用户需要实现的拦截动作，会返回一个字符串作为逻辑视图，invocation.invoke()将控制权转给下一个拦截器，或转给Action的execute（）方法。

拦截器的过滤特性：Struts2提供了MethodFilterInterceptor类，需要继承该类，重写doInterceptor（ActionInvocation invocation）来实现对Action的拦截。
其他两个方法：
1.public void setExcludeMethods(String execludeMethods)排除需要过滤的方法，即列出的方法不会被拦截
2.public void setIncludeMethods(String includeMethods)设置需要过滤的方法，即列出的方法都会被拦截
如需同时指定多个方法，方法之间使用逗号即可。两个方法都指定一个方法名，则过滤，以includeMethods参数指定的取胜。

拦截器的执行顺序：在Action的控制方法执行之前，位于拦截器链前面的拦截器将先发生作用，在Action的控制方法执行之后，位于拦截器链前面的拦截器将后发生作用。

The things that bring the greatest joy carry the greatest potential for loss and disappointment. 成长就必须面对这样的事情，
敢于面对可能的失败，不惧怕前进路上的风雨，保有你对幸福的向往，保持你的倔强和骄傲，回望时你就能对曾经的自己微笑！--Kevin

Ajax(Asynchronous JavaScript and XML)异步的JavaScript和XML技术
transient修饰的属性不会被序列化
Ajax的POST请求都是以UTF-8方式进行编码
一旦我们将某个逻辑视图配置成json类型，这将意味着该逻辑视图无需制定物理视图资源，因为JSON插件会将该Action序列化后发送给客户端

 

2014-7-15

Hibernate是轻量级的JavaEE应用的持久层解决方案，不尽管理Java类到数据库表的映射（Java数据类型到SQL数据类型的映射），还提供数据查询和获取数据的方法，可以大幅度缩短使用JDBC处理数据持久化的时间。Hibernate倡导低侵入式的设计，完全采用普通的Java对象（POJO）编程，不要求PO继承Hibernate的某个超类或者实现Hibernate的某个接口。

ORM(Object/Relation Mapping)对象/关系数据库：面向对象编程到关系数据库的映射。
ORM工具唯一的作用就是：把对持久化对象的保存，删除，修改等操作，转换成对数据库的操作，从此，程序员可以以面向对象的方式操作持久化对象，而ORM框架负责转换成对应的SQL（结构化查询语言）操作。

ORM工具提供了持久化类和数据表中间的映射关系，通过这种映射关系，可以很方便的通过持久化类实现对数据表的操作。

PO（Persistent Object）持久化对象
作用：完成持久化操作，通过该对象可对数据执行增删改的操作--以面向对象的方式操作数据库

<hibernate-mapping.../>元素下有class子元素，每个子元素映射一个PO，更准确的说是持久化类。
PO = POJO + 映射文件

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：
1. 最小连接数
是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；
2.最大连接数
是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。
3).最小连接数与最大连接数相差太大
那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。

连接池原理：连接池基本的思想是在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。使用完毕后，用户也并非将连接关闭，而是将连接放回连接池中，以供下一个请求访问使用。而连接的建立、断开都由连接池自身来管理。同时，还可以通过设置连接池的参数来控制连接池中的初始连接数、连接的上下限数以及每个连接的最大使用次数、最大空闲时间等等。也可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。

Hibernate配置文件默认文件名为hibernate.cfg.xml当程序调用Configuration对象的configure()方法时，Hibernate将自动加载文件。
Hibernate推荐使用C3P0数据源，指定数据源的配置信息，包括最大连接数，最小连接数等信息。

Hibernate默认使用SLF4J作为日志工具

Hibernate进行持久化操作的步骤：
1.开发持久类，由POJO加映射文件组成
2.获取Configuration
3.获取SessionFactory
4.获取Session,打开事务
5.用面向对象的方式操作数据库
6.关闭事务，关闭Session

Hibernate的两个显著特点：
1.不再需要使用编写SQL语句，而是允许采用OO（Object Oriented,面向对象）方式来访问数据库
2.JDBC访问过程中大量的checked异常被包装成Hibernate的Runtime异常，从而不再要求程序必须处理所有异常。

2014-7-16
敢于面对可能的失败，不惧怕前进路上的风雨，保有你对幸福的向往，保持你的倔强和骄傲，回望时你就能对曾经的自己微笑！

一个人，一个包，一个行李箱独自上路，却和着一群有着共同理想的人共同奋斗! 不为模糊不清的未来担忧，只为清清楚楚的现在努力。加油!--Kevin

很多地方上课的条件都比较艰苦，有的教室都没有空调，甚至没有电扇。有在网吧上课的，有在KTV上课的，有在溜冰场上课的，还有在水房旁边的花园上课的。如果没有成功，这些苦难只能是苦难，而且没有人会在乎你经历的这些！你只有更加努力，必须胜利！这才对的起你艰辛甚至卑微的现在！
就是因为没人在乎你，所以对自己好点吧，一定坚持下来，不要放弃，坚持就是对自己最大的好!

2014-7-17
集合类实例具体值类型的行为:当持久化对象被保存时，这些集合属性会被自动持久化，当持久化对象被删除时，这些集合属性对应的记录将被自动删除。假设集合元素被从一个持久化对象传递到另一个持久化对象，该集合元素对应的记录会从一个表转移到另一个表。
两个持久化兑现不能共享同一个集合元素的引用。

映射Set集合属性时，如果<element../>元素包括not-null="true"属性，则集合属性表示以持久化类的外键列和元素列作为联合主键，否则该表没有主键。但List集合属性的表总是以外键列和元素索引列作为联合主键。

bag元素既可以映射List集合属性，也可以映射Set集合属性，甚至可以是Collection集合属性。不管是哪种集合属性，使用<bag../>都将被映射成无序集合，该集合属性对应的表没有主键。
使用<key../>元素来映射关联的外键列，而使用<element../>元素来映射集合属性的元素列。

对于集合属性，通常推荐使用延迟加载策略，所谓延迟加载策略就是等系统需要使用集合属性时才从数据库装载关联的数据。Hibernate对集合属性默认采用延迟加载，在某些特殊的情况下，为<set../><list../><map../>等元素设置lazy="false"属性来取消延迟加载属性。

 

2014-7-18
数据库模式定义语言DDL(Data Definition Language)，是用于描述数据库中要存储的现实世界实体的语言。一个数据库模式包含该数据库中所有实体的描述定义。这些定义包括结构定义、操作方法定义等。
数据库模式定义语言并非程序设计语言，DDL数据库模式定义语言是SQL语言（结构化程序设计语言）的组成部分。SQL语言包括四种主要程序设计语言类别的语句：数据定义语言(DDL)，数据操作语言(DML)，数据控制语言(DCL)和事务控制语言（TCL）。

不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁不要浮躁

2014-7-19
人人上的某好友记录：犯了个小错误，被说得不轻，很是受益，训言如下:“我不问理由,不听借口，你做错了不是因为你没有能力,而是你太清楚自己的退路。你学会了安享，你没有低下头弯下腰去精学，去变通，你没有想着找原因，而一直在找理由。取胜并不取决于你有多少优点，而是你身上比对手更少的缺点;不在于你能力有多高,而在于你眼光与格局有多高，做什么样的工作，跟什么样的人工作，在什么样的氛围里工作，除了收入，你是否有提高个人的知识，能力，觉悟和格局，一个人的坚持是一种苦，一群人的坚持是一种幸福，你坚持了吗？做好本职，学好专业，提高业余，坚持住单薄的理想。”共勉，一处不明，何谓格局。

 

Hiberate查询
HQL是完全面向对象的查询语言，可以支持继承，多态等特性。
HQL查询依赖于Query类，每个Query实例对应一个查询对象，使用HQL查询步骤：
1.获取Hibernate Session对象
2.编写HQL语句
3.以HQL语句作为参数，调用Session的createQuery方法创建查询对象
4.如果HQL语句包含参数，则调用Query的setXxx方法作为参数赋值
5.调用Query对象的list()或者uniqueResult()方法返回查询结果列表（持久化实体集）

Query中用于实现分页控制的两个方法：
1.setFirstResult(int firstResult)设置返回的结果集从第几条记录开始
2.setMaxResult(int maxResult)设置本次查询返回的结果数目

HQL的占位符既可以使用英文问号（？），也可以使用有名字的占位符，此时应该在占位符名字前增加英文冒号（：）

当程序需要从多个数据表中取得数据时，Hibernate使用关联映射来处理底层数据表之间的链接，一旦提供了正确的关联映射后，当程序通过Hibernate进行持久化访问时，将可利用Hibernate的关联进行连接。
HQL支持两种关联连接（join）形式：隐式（implicit）与显式(explicit)
Hibernate支持的HQL连接类型有如下几种方式：
1.内连接：join
2.左外连接：left join
3.右外连接：right join
4.全连接：full join

隐式连接和显式连接的区别：
1.隐式连接底层将转换成SQL99的交叉连接，显式连接底层将转换成SQL99的inner join，等连接
2.查询后返回结果不同

注意：having子句用于分组进行过滤，只能在有group by 子句时才可以使用，没有group by子句，不能使用having子句。
group by 和order by子句都不能包含算术表达式
HQL子查询只可以在select或者where子句中出现。

 

条件查询
通过如下三个类完成：
1.Criteria:代表一次查询
2.Criterion:代表一次查询条件
3.Restrictions:产生查询条件的工具类
步骤：
1.获得Hibernate的Session对象
2.以Session对象创建Criteria对象
3.使用Restrictions的静态方法创建Criterion查询条件
4.向Criteria查询中添加Criterion查询条件
5.执行Criteria的list()或者uiqueResult（）方法返回结果集

Criteria对象并不具备任何数据筛选功能，但程序可以通过向Criteria对象中组合多个Criteria（每一个Criteria对象代表一个过滤条件）即可实现数据过滤。

事务控制
事务：是一步或者几步基本操作组成的逻辑执行单元，这些基本操作作为一个整体执行单元，它们要么全部执行，要么全部取消，绝不能仅仅执行部分。一般而言，每次用户请求，对应一个业务逻辑方法，一个业务逻辑方法往往具有逻辑的原子性，应该使用事务。
事务的4个特性：也称为ACID性
1.原子性（Atomicity），事务是应用中最小执行单位
2.一致性(Consistency)，是通过原子性保证
3.隔离性(Isolation)，各个事务互不干扰
4.持续性(Durability)，事务一旦提交，对数据所做的改变要记录到永久存储器中。

几乎在所有情况下，都不要使用每个应用对应一次Hibernate Session的模式，也尽量不要使用每次HTTP Session对应一次Hibernate Session模式。

JTA，即Java Transaction API，JTA允许应用程序执行分布式事务处理——在两个或多个网络计算机资源上访问并且更新数据。JDBC驱动程序的JTA支持极大地增强了数据访问能力。

二级缓存
Hibernate包括两个缓存：
1.默认总是启用的一级缓存,只对当前Session有效，当应用保存持久化实体，修改持久化实体时，Session并不会立即把这种改变flush到数据库，而是缓存在一级缓存中，除非程序显式调用Session的flush方法或者程序关闭Session时，才会把这些改变一次性flush到底层数据库，通过这样的方式可以减少与数据库的交互，从而提高数据库访问性能
2.二级缓存是全局性的，所有的Session都共享这个二级缓存。一旦程序中开启了二级缓存，Session抓取数据的时候，优先从二级缓存中抓取，在适当的情况下，合理地设置Hibernate的二级缓存也可以很好地提高应用的数据库访问性能。

开启二级缓存需要在hibernate.cfg.xml中配置
<property name="hibernate.cache.use_second_level_cache">true</property>
指定使用哪种二级缓存实现类
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

2014-7-20

事件机制
通常，Hibernate执行持久化过程中，应用程序无法参与其中，所有的数据持久化操作，对于用户都是透明的，用户无法插入自己的动作。
通过事件框架，Hibernate允许应用程序能响应特定的内部事件，从而允许实现某些通用的功能，或者对Hibernate功能进行扩展。
Hibernate的事件框架由两部分组成：
1.拦截器机制：对于特定动作拦截，回调应用中的特定动作
2.事件系统：重写Hibernate的事件监听器。

Spring

依赖注入（Dependency Injection）和控制反转（Inversion of Control）含义：当某个Java实例（调用者）需要另一个Java实例（被调用者）时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。在依赖注入的模式下，创建被调用者的工作不再由调用者完成，因此成为控制反转，创建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。不管是依赖注入还是控制反转都说明Spring采用动态灵活的方式来管理各种对象，对象与对象之间的具体实现相互透明。

所谓依赖注入，是指程序运行过程中，如果需要另一个对象协作（调用它的方法，访问它的属性）时，无须在代码中创建被调用者，而是依赖于外部容器的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。
依赖注入通常有如下两种：
1.设值注入：IoC容器使用属性的setter方法来注入被依赖的实例
2.构造注入：IoC容器使用构造器来注入被依赖的实例

建议采用以设值注入为主，构造注入为辅的注入策略。对于依赖关系无须变化的注入，尽量采用构造注入，而其他的依赖关系的注入则考虑采用设值注入。

 
2014-7-21

看论文，玩、

2014-7-22

当你上课感觉就像打酱油时，当你对研究生很迷茫时，当你坐在电脑前孜孜不倦时，请看下面的文章，很受用，至少我心里现在没有以前浮躁。好的文章有时能改变一个人的精神状态，下面就是其中之一。

上海大学一位老师说：“不可否认的是，研究生面临着比较大的生存压力，但是要平衡自己的方向，在没有生存威胁的情况下，要专注于学习。”他表示，在社会心理普遍比较浮躁的情况下，就要求研究生要拿出宽广的视野来，权衡自己眼前的利益和长远发展的基础，“疯狂做兼职是没有自信的表现。”他认为，研究生要从长远来看，看到社会整体的发展趋势，坚定发展的信念，不为暂时的困难所束缚，尤其是不要被眼前一时的较小的物质利益所蒙蔽。“在校研究生100万，在我国整个人口结构中占的比例是非常低的。研究生仍然是社会的精英群体，既然是精英群体，就要有责任感和使命感。”

读研首先要改变的是自己的心理状态，说起来简单，但实际上很困难。不过既然已经上了研，就不要抱怨了，努力想想自己该干啥才是王道。首先需要明确几种好的心态。

1. 无论做研究还是做工程，不要期待导师给你太多的指导，这点全世界都一样，不要抱怨，独立解决问题的能力就是这样锻炼出来的。好的导师能够在大方向上给一些意见，但具体的工作是需要自己去做的。

2. 别人没有义务来帮助你，不管是师兄或同学，最可靠的人永远是自己。别人帮助你，要表示感谢，并努力帮助别人。别人不帮助你，也不要抱怨。

3. 不要抱怨课程无聊，老师讲的不好。读到研究生，自学能力没有的话不如退学。

4. 研究生毕业不见得能找到好工作，好工作是给能力强的人，不是给学历高的人，见到nb的本科生，也要虚心学习。

 

研究生期间应该做的事情：

1. 养成锻炼身体的习惯，30以前你找病，30以后病找你。

2. 如果你学的专业，中国不是最好的，那么请好好学英语，请不要说什么英语教育是毒瘤的狗屁话，研究生毕业前，至少也要达到能够进行英语面试的准备。

3. 努力做一个善良的人，学着改变自己，控制自己的欲望。善待你周围的人。

4. 学习时间管理的方法，订计划，执行计划。这个习惯会让你终身受益。

5. 学习怎么使用google scholar，包括各类搜索方法。

6. 争取每一个能让自己能力增强的机会（实习，比赛之类的），个人建议大家要努力争取实习机会，和导师好好商量，3个月的相关领域的实习会对能力的帮助很大。对找好的工作也是一个有利的筹码。

7. 每天看书。除本专业的相关书籍外，看半个小时其它方面的书：经济学，管理学，各类励志书籍。 还可以看看一些牛人的blog。

8. 养成写东西的习惯。定期写blog是一个好办法，写做是一个锻炼自己逻辑思维能力的好办法。

9. 多动手，对cs的同学来说，多写程序，多看程序。自己去找英文论文看。

10. 培养游戏之外的一些爱好。

11. 和别人讨论的时候，先理解别人的观点，学会聆听。写了一些，如果不足，大家补充。

 

研究生毕业前应该具备的能力：

1. 能把自己的观点说清楚。口头+书面。

2. 能够顺利的专业英语论文，基本不要翻译软件。

3. 对自己的职业有初步的规划和想法。

4. 知识面扩大，做好踏入社会的准备。

5. 身体健康，还能打打球。

6. 有一帮不错的朋友，能够互相帮助。

 

2014-7-23
看论文，装opencv，配置vs2010

2014-7-24
中科大28岁美女博导方璐：如果遇到困难就想着放弃，那也许这辈子就什么事情都做不好了。做研究是厚积薄发的过程，当积累到一定时候却依然没有成果，很可能是最难熬的阶段，熬过这个坎儿，前方的路会越来越清楚。

 

2014-7-25
Forensic investigation of ooxml format documents
看wxh的代码

2014-7-26
She is the type that 看一眼就忍不住心里的冲动，好想冲上去给她一个大大的拥抱，给她一个深情的拥吻。

Be the change you want to see in the world
通过改变自身来适应万变的世界

2014-7-27
昨天买的石头哥的《摸着石头过河》这不能书，快递今天到了，简直爱不释手，石头哥是我膜拜的偶像之一，他讲的话没有太过于难懂，却能句句深入我心，实乃我的精神食粮。

2014-7-28

Title:What can I start doing now that will help me a lot in about five years?
现在开始做一些什么事情可以在5年之后大为受益？

I'm 23 years old and currently a physics student with large desire for progress, not only in my profession but also in all aspects of life.

我是一个23岁的学物理渴望进步的学生，除了我专业知识之外我做一些别的什么比较好？

 

Answer by David Cannon, FindProz.com Co-founder

There’s already a lot here and you probably stopped reading, but I couldn’t resist writing a note to my 23 year old self:

虽然很长你读不完，不过我真的很想把这些写给23岁的我：

 

If you do anything, do this first one: learn how to work hard and stick with something. Learn how to turn off Facebook and control your addiction to social media. You’ll instantly be ahead of 90% of your generation.
先学会这一点：无论做什么事情，都努力，坚持的做完。 一旦你学会了控制自己不要去玩社交媒体，学会不去刷Facebook, 你就已经比你同辈90%的人都要进步了。
Video games are a time sink. If you can play for an hour and say “That was fun, let’s do something else” then you’re ok. Otherwise, just get rid of them.
玩游戏就跟浪费时间没区别。 除非你真能控制住只玩一小时之后愉快的去干别的事情，不然还是戒了吧。
Pick up an athletic hobby that you can do through the years, or your sedentary academic lifestyle will do horrible things to your posture, back, and gut.
选一项运动当成兴趣，不然你的学术生涯会把你的身子毁掉。
Learn how to deal with interpersonal conflicts. Read Crucial Conversations and practice – it’s a lifechanger (shameless plug: Crucial Conversations Tools for Talking When Stakes Are High, Second Edition)
学会处理人际冲突… 上面这本书就不错
Learn as much programming as you can. It’s never a bad idea to learn a programming language
尽可能多的学编程，这永远不是一件坏事。
Learn how to display data in R.
学会怎么用R语言来处理数据。
Learn how to talk on the phone with people you don’t know. It still terrifies most people. Get a phone sales job and quit after a few weeks.
学会怎么在电话上跟陌生人交流。 去找一个电话销售的工作，干几个礼拜辞职就好。
Start some kind of little side venture to learn entrepreneurial principles. Start a window washing business, buy and sell stuff on Craigslist, do anything. You might need them if you’re in between jobs.
做一些小活来学会创业。 比如洗窗户啦，在Craigslist上卖点小玩意啦。 以后工作中你会用得到这些技能。
Take a course on statistics and how they’re misused, specifically how faulty causal arguments are made. It will change the way you approach almost any discussion, quantitative or not.
上一些统计学的课，知道他们是怎么被误用的。 将来对于识别一些谬论很有帮助。
Always have a private place where you can talk out loud to God every day. Even if you’re not religious or don’t believe in God. Talk out loud to the universe. Sort out your thoughts, verbalize them, and then write down what comes to mind. Something wiser than you is listening and responding, even if it’s just another side of you.
找一个属于自己的可以大声跟上帝说话地方。 哪怕你不信教，你可以就试着大声跟宇宙说话吧。 理清你的思绪，然后写下来。
Use http://Mint.com to track your expenses. Make a budget and learn how to stick to it. Learn to live lean now while you can, so you won’t be forced to later on.
用记录软件记录每天的开销，学会做预算。 学会过一些简朴的生活。
Learn a foreign language, but only if you anticipate using it.
学一门平常会用的外语。
Learn how to network. Read “Never Eat Alone.” (plug:http://amzn.to/XQqfrM). Hint: it’s about doing things for other people.
学会处理人际关系。这就是怎么跟人打交道的学问。
Learn how to cook tasty, cheap food.
学会做一些简单又好吃的饭。。
Find music that inspires you and makes you feel alive.Listen to it every morning and if it’s something embarrassing just don’t tell your friends about it.
找些能够激励你的音乐。 每天早上起床后听着它。
Save up a few thousand dollars and go somewhere crazy with a few friends. Live in a hostel for a few weeks. It will change your life and you will think about it forever
攒个几千块钱，可以跟一些朋友去外面疯狂一次。 比如在青年旅店里住上几个星期，会改变你整个人生的看法。
When someone promises you easy money, run the other way. Yes, it IS a scam.
如果有人给你很容易挣钱的方法，别信，基本都是骗子。
Read a book a week. When you get ridiculously wealthy, read a book a day. Read fiction too.
每周读一本书，等你成为土豪的时候，每天读一本。

 

2014-7-29

培根：读书有三个用途--娱乐、装饰和增长才识。

《伤仲永》是北宋文学家王安石创作的一篇散文。讲述了一个江西金溪人名叫“方仲永”的神童因后天父亲不让他学习和被父亲当作造钱工具而沦落到一个普通人的故事。文章借仲永为例，告诫人们决不可单纯依靠天资而不去学习新知识，必须注重后天的教育和学习，强调了后天教育和学习对成才的重要性。

毛泽东《咏蛙》
独坐池塘如虎踞，
绿荫树下养精神。
春来我不先开口，
哪个虫儿敢作声。

男儿立志出乡关，
学若不成死不还。
埋骨何期，
人间到处有青山。
——宋·月性（和尚）·《题壁诗》

男儿立志出乡关，
学不成名死不还。
埋骨何须桑梓地，
人生无处不青山。
——日本明治维新时期著名政治活动家西乡隆盛

要想长见识，自学实际上是最佳，最有效的途径，原因是自学是自发的，自觉的，并且自学只会学习自己真正感兴趣的知识，这样积极的学习远远强于被动的，强制的灌输性学习，所以为了提高自我必须自学，而为了进入别人的领域才需要上学。

俗话说，无志之人常立志，有志之人立长志，其实这只是一种表象。学生时代常犯的错误就是常立志，最终多数人变成了无志之人，常见的解释是由于不坚持无恒心，其实这样的解释是浅薄的。关键是坚持不是人们想象的那样，只是自己意志的因素，而是各种因素综合的结果，坚持的先决条件是方向对，路线对，不断有成方能坚持。如果外在条件不合适，当事人自己再怎么坚持也很难成功。举例来讲，一颗种子要发芽需要土壤与水分，而不是在石板上坚持。青年人求学，大多喜欢谈立志，诸如将来要当军事家、政治家、教育家等。而毛泽东则认为，离开真理来谈立志，只是对前人中有成就者的简单模仿，真正的立志，首先是寻找真理，然后按它去做，而不是张嘴就来。在没有找到真理的情况下，为了一个自我设定的高尚的目标努力学习，大约是最正常的最积极的做法。虽然积极努力的学习并不意味着就一定能找到正确的路径，但先学起来是不会有错的。

你想与高人过招吗？先让自己的本事大起来，你想看得更远吗？先往高处爬。天上不会掉馅饼，知识不会自动跑到你的脑袋里，大家都是学生，凭什么老天会眷顾你？

读书只能获得更高学历，高学历只能说明你获得了某种资格，是一张参加更高级别竞争的入场劵，在这新的竞技场上，你的对手可能比你还要优秀，可能比你还要能吃苦和拥有更坚定的意志力，可能比你更有人缘，总之一切皆有可能，唯一没有可能的就是你遇到的竞争对手是白痴弱智。你的目标越高，心劲越大，你的竞争者也就越强。这就是毕业生们共同面对的现实，醒醒吧，你将与强者竞争，你将踩住狮子，将拔掉龙牙？

2014-8-6
One thing you learn when you're walking the steps is that you never outsource a blame that belongs in your own backyard. 自己做的事情无法怪罪于他人。