2012年7月6日

js通过ajax传给后台一个json数组字符串：

        CSS之所以会如此流行，是它具备以下的优点

      1、符合W3C标准。保证网站不会因为将来网络应用的升级而被淘汰。     
      2、支持浏览器的向后兼容，也就是无论未来的浏览器大战，胜利的是IE、chrome或者是火狐，网站都能很好的兼容。     
     3、搜索引擎更加友好。相对与传统的table, 采用DIV+CSS技术的网页，更加容易被搜索引擎找到。     
     4、样式的调整更加方便。内容和样式的分离，使页面和样式的调整变得更加方便，可以一次性修改多个网页的样式，只修改样式不需要重新发布。
     5、降低网页大小，对于一个大型网站来说，可以节省大量带宽，大大提高用户体验，这是非常重要的一点——用户至上。  

在网上会有很多关于struts2结合autocomplet插件的实例，但是不怎么完整，让人感觉不清楚，刚刚在公司做了一个关于这个的项目，页面也用到了这个插件，所以把详细的步骤和注意事项贴出来和大家分享，废话不多说，贴铁代码：本文代码下载地址：http://download.csdn.net/detail/harderxin/4504612

一、我的资源中有autcomplet的json实例和autocomplet的源代码，也是copy网上的，大家可以免费下载，下载地址：http://download.csdn.net/detail/harderxin/4504288

二、开始我们的案例旅程

  1、编写页面index.jsp

PS：在所有例子中正则表达式匹配结果包含在源文本中的【和】之间，有的例子会使用java来实现，如果是java本身正则表达式的用法，会在相应的地方说明。所有java例子都在JDK1.6.0_13下测试通过。

一、对特殊字符进行转义

         元字符是一些在正则表达式里有着特殊含义的字符。因为元字符在正则表达式里有着特殊的含义，所以这些字符就无法用来代表它们本身。在元字符前面加上一个反斜杠就可以对它进行转义，这样得到的转义序列将匹配那个字符本身而不是它特殊的元字符含义。如，如果想要匹配[和]，就必须对它进行转义：\[和\]。

         对元字符转义需要用到斜杠\字符，这就意味着\字符本向也是一个元字符，要匹配\字符本身，必须转义成\\。如匹配windows文件路径。

二、匹配空白字符

         元字符大致可以分为两种：一种是用来匹配文本的（如.），另一种是正则表达式的语法所要求的（如[和]）。

         在进行正则表达式搜索的时候，我们经常会遇到需要对原始文本中里的非打印空白字符进行匹配的情况。比如说，我们可能需要把所有的制表符找出来，或者我们需要把换行符找出来，这类字符很难被直接输入到一个正则表达式里，这时我们可以使用如下列出的特殊元字符来输入它们：

         \b     回退（并删除）一个字符（Backspace键）

         \f      换页符

         \n     换行符

         \r      回车符

         \t      制表符（Tab键）

         \v      垂直制表符

         来看一个例子，把文件中的空白行去掉：

文本：

8 5 4 1 6 3  2 7 9

7 6 2 9 5 8  3 4 1

9 3 1 4 2 7  8 5 6

6 9 3 8 7 5  1 2 4

5 1 8 3 4 2  6 9 7

2 4 7 6 1 9  5 3 8

3 26  7 8 4 9 1 5                                                       

4 8 9 5 3 1  7 6 2

1 7 5 2 9 6  4 8 3

正则表达式：\r\n\r\n

分析：\r\n匹配一个回车+换行组合，windows操作系统中把它作为文本行的结束标签。使用正则表达式\r\n\r\n进行的搜索将匹配两个连续的行尾标签，而这正好是空白行。

         注意：Unix和Linux操作系统中只使用一个换行符来结束一个文本行，换句话说，在Unix或Linux系统中匹配空白行只使用\n\n即可，不需要加上\r。同时适用于windows和Unix/Linux的正则表达式应该包括一个可先的\r和一个必须匹配的\n，即\r?\n\r?\n，这将会在后面的文章中讲到。

         Java代码如下：

原内容：

8 5 4  1 6 3 2 7 9

7 6 2  9 5 8 3 4 1

9 3 1  4 2 7 8 5 6

6 9 3  8 7 5 1 2 4

5 1 8  3 4 2 6 9 7

2 4 7  6 1 9 5 3 8

3 2 6  7 8 4 9 1 5

4 8 9  5 3 1 7 6 2

1 7 5  2 9 6 4 8 3

处理后：-----------------------------

8 5 4  1 6 3 2 7 9

7 6 2  9 5 8 3 4 1

9 3 1  4 2 7 8 5 6

6 9 3  8 7 5 1 2 4

5 1 8  3 4 2 6 9 7

2 4 7  6 1 9 5 3 8

3 2 6  7 8 4 9 1 5

4 8 9  5 3 1 7 6 2

1 7 5  2 9 6 4 8 3

三、匹配特定的字符类别

         字符集合（匹配多个字符中的某一个）是最常见的匹配形式，而一些常用的字符集合可以用特殊元字符来代替。这些元字符匹配的是某一类别的字符（类元字符），类元字符并不是必不可少的，因为可以通过逐一列举有关字符或通过定义一个字符区间来匹配某一类字符，但是使用它们构造出来的正则表达式简明易懂，在实际应用中很常用。

         1、匹配数字与非数字

         \d     任何一个数字，等价于[0-9]或[0123456789]

         \D     任何一个非数字，等价于[^0-9]或[^0123456789]

         2、匹配字母和数字与非字母和数字

         字母（A-Z不区分大小写）、数字、下划线是一种常用的字符集合，可用如下类元字符：

         \w    任何一个字母（不区分大小写）、数字、下划线，等价于[0-9a-zA-Z_]

         \W    任何一个非字母数字和下划线，等价于[^0-9a-zA-Z_]

         3、匹配空白字符与非空白字符

         \s      任何一下空白字符，等价于[\f\n\r\t\v]

         \S      任何一下空白字符，等价于[^\f\n\r\t\v]

         注意：退格元字符\b没有不在\s的范围之内。

         4、匹配十六进制或八进制数值

         十六进制：用前缀\x来给出，如：\x0A对应于ASCII字符10（换行符），其效果等价于\n。

         八进制：用前缀\0来给出，数值本身可以是两位或三位数字，如：\011对应于ASCII字符9（制表符），其效果等价于\t。

四、使用POSIX字符类

         POSIX字符类是很多正则表达式实现都支持的一种简写形式。Java也支持它，但JavaScript不支持。POSIX字符如下所示：

[:alnum:]  任何一个字母或数字，等价于[a-zA-Z0-9]

[:alpha:]   任何一个字母，等价于[a-zA-Z]

[:blank:]   空格或制表符，等价于[\t]

[:cntrl:]     ASCII控制字符（ASCII 0到31，再加上ASCII 127）

[:digit:]     任何一个数字，等价于[0-9]

[:graph:]  任何一个可打印字符，但不包括空格

[:lower:]   任何一个小写字母，等价于[a-z]

[:print:]    任何一个可打印字符

[:punct:]   既不属于[:alnum:]和[:cntrl:]的任何一个字符

[:space:]  任何一个空白字符，包括空格，等价于[^\f\n\r\t\v]

[:upper:]  任何一个大写字母，等价于[A-Z]

[:xdigit:]   任何一个十六进制数字，等价于[a-fA-F0-9]

         POSIX字符和之前见过的元字符不太一样，我们来看一个前面利用正则表达式来匹配网页中的颜色的例子：

文本：<span style="background-color:#3636FF;height:30px;width:60px;">测试</span>

正则表达式：#[[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]]

结果：<span style="background-color:【#3636FF】;height:30px;width:60px;">测试</span>

注意：这里使用的模式以[[开头、以]]结束，这是使用POSIX字符类所必须的，POSIX字符必须括在[:和:]之间，外层[和]字符用来定义一个集合，内层的[和]字符是POSIX字符类本身的组成部分。

在java中的POSIX字符表示有所不同，不是包括在[:和:]之间，而是以\p开头，包括在{和}之间，且大小写有区别，同时增加了\p{ASCII}，如下所示：

\p{Alnum}         字母数字字符：[\p{Alpha}\p{Digit}]

\p{Alpha}          字母字符：[\p{Lower}\p{Upper}]

\p{ASCII}           所有 ASCII：[\x00-\x7F]

\p{Blank}           空格或制表符：[ \t]

\p{Cntrl}            控制字符：[\x00-\x1F\x7F]

\p{Digit}            十进制数字：[0-9]

\p{Graph}          可见字符：[\p{Alnum}\p{Punct}]

\p{Lower}          小写字母字符：[a-z]

\p{Print}            可打印字符：[\p{Graph}\x20]

\p{Punct}          标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

\p{Space}          空白字符：[ \t\n\x0B\f\r]

\p{Upper}          大写字母字符：[A-Z]

\p{XDigit}          十六进制数字：[0-9a-fA-F]

PS：在所有例子中正则表达式匹配结果包含在源文本中的【和】之间，有的例子会使用java来实现，如果是java本身正则表达式的用法，会在相应的地方说明。所有java例子都在JDK1.6.0_13下测试通过。

一、有多少个匹配

         前面几篇讲的都是匹配一个字符，但是一个字符或字符集合要匹配多次，应该怎么做呢？比如要匹配一个电子邮件地址，用之前说到的方法，可能有人会写出像\w@\w\.\w这样的正则表达式，但这个只能匹配到像a@b.c这样的地址，明显是不正确的，接下来就来看看如何匹配电子邮件地址。

         首先要知道电子邮件地址的组成：以字母数字或下划线开头的一组字符，后面跟@符号，再后面是域名，即用户名@域名地址。不过这也跟具体的邮箱服务提供商有关，有的在用户名中也允许.字符。

1、匹配一个或多个字符

         要想匹配同一个字符（或字符集合）的多次重复，只要简单地给这个字符（或字符集合）加上一个+字符作为后缀就可以了。+匹配一个或多个字符（至少一个）。如：a匹配a本身，a+将匹配一个或多个连续出现的a；[0-9]+匹配多个连续的数字。

         注意：在给一个字符集合加上+后缀的时候，必须把+放在字符集合的外面，否则就不是重复匹配了。如[0-9+]这样就表示数字或+号了，虽然语法上正确，但不是我们想要的了。

文本：Hello, mhmyqn@qq.com or mhmyqn@126.com is my email.

正则表达式：\w+@(\w+\.)+\w+

结果：Hello, 【mhmyqn@qq.com】 or 【mhmyqn@126.com】 is my email.

分析：\w+可以匹配一个或多个字符，而子表达式(\w+\.)+可匹配像xxxx.edu.这样的字符串，而最后不会是.字符结尾，所以后面还会有一个\w+。像mhmyqn@xxxx.edu.cn这样的邮件地址也会匹配到。

2、匹配零个或多个字符

         匹配零个或多个字符使用元符*，它的用法和+完全一样，只要把它放在一下字符或字符集合的后面，就可以匹配该字符（或字符集合）连续出现零次或多次。如正则表达式ab*c可以匹配ac、abc、abbbbbc等。

3、匹配零个或一个字符

         匹配零个或一个字符使用元字符?。像上一篇说到的匹配一个空白行使用正则表达式\r\n\r\n，但在Unix和Linux中不需要\r，就可以使用元字符?，\r?\n\r?\n这样既可匹配windows中的空白行，也可匹配Unix和Linux中的空白行。下面来看一个匹配http或https协议的URL的例子：

文本：The URL is http://www.mikan.com, to connect securely use https://www.mikan.cominstead.

正则表达式：https?://(\w+\.)+\w+

结果：The URL is 【http://www.mikan.com】, to connect securely use 【https://www.mikan.com】 instead.

分析：这个模式以https?开头，表示?之前的一个字符可以有，也可以没有，所以它能匹配http或https，后面部分和前一个例子一样。

二、匹配的重复次数

         正则表达式里的+、*和?解决了很多问题，但是：

         1）+和*匹配的字符个数没有上限。我们无法为它们将匹配的字符个数设定一个最大值。

         2）+、*和?至少匹配一个或零个字符。我们无法为它们将匹配的字符个数另行设定一个最小值。

         3）如果只使用*和+，我们无法把它们将匹配的字符个数设定为一个精确的数字。

         正则表达式里提供了一个用来设定重复次数的语法，重复次数要用{和}字符来给出，把数值写在它们中间。

         1、为重复匹配次数设定一个精确值

         如果想为重复匹配次数设定一个精确的值，把那个数字写在{和}之间即可。如{4}表示它前面的那个字符（或字符集合）必须在原始文本中连续重复出现4次才算是一个匹配，如果只出现了3次，也不算是一个匹配。

         如前面几篇中说到的匹配页面中颜色的例子，就可以用重复次数来匹配：#[[:xdigit:]]{6}或#[0-9a-fA-F]{6}，POSIX字符在java中是#\\p{XDigit}{6}。

         2、为重复匹配次数设定一个区间

         {}语法还可以用来为重复匹配次数设定一个区间，也就是为重复匹配次数设定一个最小值和最大值。这种区间必须以{n, m}这样的形式给出，其中n>=m>=0。如检查日期格式是否正确（不检查日期的有效性）的正则表达式（如日期2012-08-12或2012-8-12）：\d{4}-\d{1,2}-\d{1,2}。

         3、匹配至少重复多少次

         {}语法的最后一种用法是给出一个最小的重复次数（但不必给出最大重复次数），如{3,}表示至少重复3次。注意：{3,}中一定要有逗号，而且逗号后不能有空格。否则会出错。

         来看一个例子，使用正则表达式把所有金额大于$100的金额找出来：

文本：

$25.36

$125.36

$205.0

$2500.44

$44.30

正则表达式：$\d{3,}\.\d{2}

结果：

$25.36

【$125.36】

【$205.0】

【$2500.44】

$44.30

         +、*、?可以表示成重复次数：

         +等价于{1,}

         *等价于{0,}

         ?等价于{0,1}

三、防止过度匹配

         ?只能匹配零个或一个字符，{n}和{n,m}也有匹配重复次数的上限，但是像*、+、{n,}都没有上限值，这样有时会导致过度匹配的现象。

         来看匹配一个html标签的例子

文本：

Yesterday is <b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>.

正则表达式：<[Bb]>.*</[Bb]>

结果：

Yesterday is 【<b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>】.

分析：<[Bb]>匹配<b>标签（不区分大小写），</[Bb]>匹配</b>标签（不区分大小写）。但结果却不是预期的那样有三个，第一个</b>标签之后，一直到最后一个</b>之间的东西全部匹配出来了。

         为什么会这样呢？因为*和+都是贪婪型的元字符，它们在匹配时的行为模式是多多益善，它们会尽可能从一段文本的开头一直匹配到这段文本的末尾，而不是从这段文本的开头匹配到碰到第一个匹配时为止。

         当不需要这种贪婪行为时，可以使用这些元字符的懒惰型版本。懒惰意思是匹配尽可能少的字符，与贪婪型相反。懒惰型元字符只需要给贪婪型元字符加上一个?后缀即可。下面是贪婪型元字符的对应懒惰型版本：

         *       *?

         +       +?

         {n,}   {n,}?

         所以上面的例子中，正则表达式只需要改成<[Bb]>.*?</[Bb]>即可，结果如下：

<b>history</b>

<B>mystery</B>

<b>gift</b>

四、总结

         正则表达式的真下威力体现在重复次数匹配方面。这里介绍了+、*、?几种元字符的用法，如果要精确的确定匹配次数，使用{}。元字符分贪婪型和懒惰型两种，在需要防止过度匹配的场合下，请使用懒惰型元字符来构造正则表达式

    根据我近些年在IT行业的摸爬滚打，发现作为一个合格的开发经理需要做的第一件事情是：规范。

1、规范代码

    每个公司都有自己的规范文档，但是很少有同学按照规范标准来写自己的代码。这样导致代码风格多元化、代码逻辑可爱化，更有甚者，会有人连自己的代码都看不懂。为什么？原因很简单，虽然写了规范文档，做了规范培训，但是没有强制的执行和跟踪。

    我认为作为一个合格的开发经理，需要做如下三件事情。第一步，写代码规范文档，做培训。第二步，按照规范生成开发模版，规定手下的所有开发人员的开发工具中导入此模版。第三步，反复核查开发人员的代码（3-6个月），直到规范成为一种习惯。

2、规范文档

    文档在中国IT公司几乎不受太大的重视。

    在项目型的公司，要么就是没有文档，要么就是文档泛滥（要知道，有很多文档是做给QA看的，其实都是垃圾），我有时候就想，这样有意义吗？文档的目的是开发人员的辅助工具，尤其对于刚入职公司的新人而言，不会有几个“好心肠”的老员工去帮助新员工讲解项目架构和原理的，进来了就是靠自己摸索，那么文档对于新人就显得尤为重要了。所以，要么就建立一个好的培训机制，要么就写好文档，如果两者都做的很好为最佳。

    在互联网公司，对于一些生命周期短暂的小项目不写文档我同意，毕竟需要时间成本。但是这样的项目代码规范一定严格，尽量精细到数据库字段的规范。因为这种类型的项目开发人员一般为1人，如果此人离开，后来人员交接时，能够更快的看懂对方的代码，以节省时间。此外，对于核心项目，一定需要一套完整的API文档，以供各项目组之间的互通，减少不必要的沟通。

    总结：正是因为没有合理的规范，某个模块的开发人员离职，会消耗公司的巨大维护成本。如果能够做到以上两点规范，相信能够给公司带来更多的效能。

 如果 mysql 是刚安装， 那么 root 的密码默认为空。 可以使用以下方法修改密码：

Java代码  

1. mysqladmin -u root password PASSWORD  

  如果 root 有密码， 那么使用以下命令修改：

Java代码  

1. mysqladmin -u root -p'oldpassword' password newpass  

  另外还可以通过登录 sql 控制台后修改：

Sql代码  

1. update user set password=PASSWORD("NEWPASSWORD") where User='root';  
2. flush privileges;  

APNS 是什么?

APNS (Android Push Notification Service) 是一种在 android 上轻松实现 push notification 的功能的解决方案. 只需申请一个 API Key, 经过简单的步骤即可实现 push notification 的功能.

特点:

http://zen-mobi.com/get_api_key.php获取apikey

ch:Channel Id devId:接收设备 Id msg:消息 random:随机数 hash:md5(ch + devId + msg + random + apiKey)

默认的浏览器都列出让用户选择的

Java代码

Uri u = Uri.parse(url);

Intent it = new Intent(Intent.ACTION_VIEW, url); TestActivity.this.startActivity(it);

Uri u = Uri.parse(url);

Intent it = new Intent(Intent.ACTION_VIEW, url); TestActivity.this.startActivity(it);

指定浏览器的

Java代码

Uri u = Uri.parse(url);

it.setData(u);

it.setAction( Intent.ACTION_VIEW);

it.setClassName("com.android.browser","com.android.browser.BrowserActivity");

TestActivity.this.startActivity(it);

spring 的三种注入方式

1. 接口注入（ 不推荐 ）

2. getter ， setter 方式注入（ 比较常用 ）

3. 构造器注入（ 死的应用 ）

关于 getter 和 setter 方式的注入

· autowire="defualt"

· autowire=“byName”

· autowire="bytype"

详细解析注入方式

例如：有如下两个类需要注入

第一个类：

第二个类：

常用getter&&setter方式介绍

方式第一种注入：

方式第二种注入： byName

方式第三种注入： byType

autowire="constructor"
需要在 Order.java 中加入一个构造器

XML配置文件

三种注入方式比较

接口注入：

接口注入模式因为具备侵入性，它要求组件必须与特定的接口相关联，因此并不被看好，实际使用有限。
Setter 注入：

对于习惯了传统 javabean 开发的程序员，通过 setter 方法设定依赖关系更加直观。

如果依赖关系较为复杂，那么构造子注入模式的构造函数也会相当庞大，而此时设值注入模式则更为简洁。

如果用到了第三方类库，可能要求我们的组件提供一个默认的构造函数，此时构造子注入模式也不适用。

构造器注入：

在构造期间完成一个完整的、合法的对象。

所有依赖关系在构造函数中集中呈现。

依赖关系在构造时由容器一次性设定，组件被创建之后一直处于相对“不变”的稳定状态。

只有组件的创建者关心其内部依赖关系，对调用者而言，该依赖关系处于“黑盒”之中。

总结

 

理论上：第三种注入方式（构造函数注入）在符合java使用原则上更加合理，第二种注入方式（setter注入）作为补充。

统一目录下的资源结构图：

只有在学会处理异常之后，我们才能说自己是一个合格的java程序员。只有在摆脱了以下六种异常处理的陋习之后，才能威慑一下刚毕业的小菜鸟。

　　现在就来测试一下大家对异常的掌握程度。不用担心，事实上，这些不合理的设计很容易看出来。那么，以下六种不合理的代码，大家能看出每一种的问题出在哪儿吗？

　　OutputStreamWriter out = ...

　　java.sql.Connection conn = ...

　　try { // ⑸

　　Statement stat = conn.createStatement();

　　ResultSet rs = stat.executeQuery(

　　"select uid, name from user");

　　while (rs.next())

　　{

　　out.println("ID：" + rs.getString("uid") // ⑹

　　+ "，姓名：" + rs.getString("name"));

　　}

　　conn.close(); // ⑶

　　out.close();

　　}

　　catch(Exception ex) // ⑵

　　{

　　ex.printStackTrace(); //⑴，⑷

　　}

　　作为一个Java程序员，你至少应该能够找出两个问题。但是，如果你不能找出全部六个问题，请继续阅读本文。

　　本文讨论的不是Java异常处理的一般性原则，因为这些原则已经被大多数人熟知。我们要做的是分析各种可称为“反例”(anti-pattern)的违背优秀编码规范的常见坏习惯，帮助读者熟悉这些典型的反面例子，从而能够在实际工作中敏锐地察觉和避免这些问题。

　　反例之一：丢弃异常

　　代码：15行-18行。

　　这段代码捕获了异常却不作任何处理，可以算得上Java编程中的杀手。从问题出现的频繁程度和祸害程度来看，它也许可以和C/C++程序的一个恶名远播的问题相提并论？？不检查缓冲区是否已满。如果你看到了这种丢弃(而不是抛出)异常的情况，可以百分之九十九地肯定代码存在问题(在极少数情况下，这段代码有存在的理由，但最好加上完整的注释，以免引起别人误解)。

　　这段代码的错误在于，异常(几乎)总是意味着某些事情不对劲了，或者说至少发生了某些不寻常的事情，我们不应该对程序发出的求救信号保持沉默和无动于衷。调用一下printStackTrace算不上“处理异常”。不错，调用printStackTrace对调试程序有帮助，但程序调试阶段结束之后，printStackTrace就不应再在异常处理模块中担负主要责任了。

　　丢弃异常的情形非常普遍。打开JDK的ThreadDeath类的文档，可以看到下面这段说明：“特别地，虽然出现ThreadDeath是一种‘正常的情形’，但ThreadDeath类是Error而不是Exception的子类，因为许多应用会捕获所有的Exception然后丢弃它不再理睬。”这段话的意思是，虽然ThreadDeath代表的是一种普通的问题，但鉴于许多应用会试图捕获所有异常然后不予以适当的处理，所以JDK把 ThreadDeath定义成了Error的子类，因为Error类代表的是一般的应用不应该去捕获的严重问题。可见，丢弃异常这一坏习惯是如此常见，它甚至已经影响到了Java本身的设计。

　　那么，应该怎样改正呢？主要有四个选择：

　　1、处理异常。针对该异常采取一些行动，例如修正问题、提醒某个人或进行其他一些处理，要根据具体的情形确定应该采取的动作。再次说明，调用printStackTrace算不上已经“处理好了异常”。

　　2、重新抛出异常。处理异常的代码在分析异常之后，认为自己不能处理它，重新抛出异常也不失为一种选择。

　　3、把该异常转换成另一种异常。大多数情况下，这是指把一个低级的异常转换成应用级的异常(其含义更容易被用户了解的异常)。

　　4、不要捕获异常。

　　结论一：既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后又把它丢弃，不予理睬。

　　反例之二：不指定具体的异常

　　代码：15行。

　　许多时候人们会被这样一种“美妙的”想法吸引：用一个catch语句捕获所有的异常。最常见的情形就是使用catch(Exceptionex)语句。但实际上，在绝大多数情况下，这种做法不值得提倡。为什么呢？

　　要理解其原因，我们必须回顾一下catch语句的用途。catch语句表示我们预期会出现某种异常，而且希望能够处理该异常。异常类的作用就是告诉Java编译器我们想要处理的是哪一种异常。由于绝大多数异常都直接或间接从java.lang.Exception派生，catch(Exceptionex)就相当于说我们想要处理几乎所有的异常。

　　再来看看前面的代码例子。我们真正想要捕获的异常是什么呢？最明显的一个是SQLException，这是JDBC操作中常见的异常。另一个可能的异常是IOException，因为它要操作OutputStreamWriter.显然，在同一个catch块中处理这两种截然不同的异常是不合适的。如果用两个catch块分别捕获SQLException和IOException就要好多了。这就是说，catch语句应当尽量指定具体的异常类型，而不应该指定涵盖范围太广的Exception类。

　　另一方面，除了这两个特定的异常，还有其他许多异常也可能出现。例如，如果由于某种原因，executeQuery返回了null，该怎么办？答案是让它们继续抛出，即不必捕获也不必处理。实际上，我们不能也不应该去捕获可能出现的所有异常，程序的其他地方还有捕获异常的机会？？直至最后由 JVM处理。

　　结论二：在catch语句中尽可能指定具体的异常类型，必要时使用多个catch.不要试图处理所有可能出现的异常。

　　反例之三：占用资源不释放

　　代码：3行-14行。

　　异常改变了程序正常的执行流程。这个道理虽然简单，却常常被人们忽视。如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，也要正确释放占用的资源。为此，Java提供了一个简化这类操作的关键词finally.

　　finally是样好东西：不管是否出现了异常，Finally保证在try/catch/finally块结束之前，执行清理任务的代码总是有机会执行。遗憾的是有些人却不习惯使用finally.

　　当然，编写finally块应当多加小心，特别是要注意在finally块之内抛出的异常？？这是执行清理任务的最后机会，尽量不要再有难以处理的错误。

　　结论三：保证所有资源都被正确释放。充分运用finally关键词。

　　反例之四：不说明异常的详细信息

　　代码：3行-18行。

　　仔细观察这段代码：如果循环内部出现了异常，会发生什么事情？我们可以得到足够的信息判断循环内部出错的原因吗？不能。我们只能知道当前正在处理的类发生了某种错误，但却不能获得任何信息判断导致当前错误的原因。

　　printStackTrace的堆栈跟踪功能显示出程序运行到当前类的执行流程，但只提供了一些最基本的信息，未能说明实际导致错误的原因，同时也不易解读。

　　因此，在出现异常时，最好能够提供一些文字信息，例如当前正在执行的类、方法和其他状态信息，包括以一种更适合阅读的方式整理和组织printStackTrace提供的信息。

　　结论四：在异常处理模块中提供适量的错误原因信息，组织错误信息使其易于理解和阅读。

　　反例之五：过于庞大的try块

　　代码：3行-14行。

　　经常可以看到有人把大量的代码放入单个try块，实际上这不是好习惯。这种现象之所以常见，原因就在于有些人图省事，不愿花时间分析一大块代码中哪几行代码会抛出异常、异常的具体类型是什么。把大量的语句装入单个巨大的try块就象是出门旅游时把所有日常用品塞入一个大箱子，虽然东西是带上了，但要找出来可不容易。

　　一些新手常常把大量的代码放入单个try块，然后再在catch语句中声明Exception，而不是分离各个可能出现异常的段落并分别捕获其异常。这种做法为分析程序抛出异常的原因带来了困难，因为一大段代码中有太多的地方可能抛出Exception.

　　结论五：尽量减小try块的体积。

　　反例之六：输出数据不完整

　　代码：7行-11行。

　　不完整的数据是Java程序的隐形杀手。仔细观察这段代码，考虑一下如果循环的中间抛出了异常，会发生什么事情。循环的执行当然是要被打断的，其次，catch块会执行？？就这些，再也没有其他动作了。已经输出的数据怎么办？使用这些数据的人或设备将收到一份不完整的(因而也是错误的)数据，却得不到任何有关这份数据是否完整的提示。对于有些系统来说，数据不完整可能比系统停止运行带来更大的损失。

　　较为理想的处置办法是向输出设备写一些信息，声明数据的不完整性;另一种可能有效的办法是，先缓冲要输出的数据，准备好全部数据之后再一次性输出。

　　结论六：全面考虑可能出现的异常以及这些异常对执行流程的影响。

　　改写后的代码

　　根据上面的讨论，下面给出改写后的代码。也许有人会说它稍微有点？嗦，但是它有了比较完备的异常处理机制。

　　OutputStreamWriter out = ...

　　java.sql.Connection conn = ...

　　try {

　　Statement stat = conn.createStatement();

　　ResultSet rs = stat.executeQuery(

　　"select uid, name from user");

　　while (rs.next())

　　{

　　out.println("ID：" + rs.getString("uid") + "，姓名: " + rs.getString("name"));

　　}

　　}

　　catch(SQLException sqlex)

　　{

　　out.println("警告：数据不完整");

　　throw new ApplicationException("读取数据时出现SQL错误", sqlex);

　　}

　　catch(IOException ioex)

　　{

　　throw new ApplicationException("写入数据时出现IO错误", ioex);

　　}

　　finally

　　{

　　if (conn != null) {

　　try {

　　conn.close();

　　}

　　catch(SQLException sqlex2)

　　{

　　System.err(this.getClass().getName() + ".mymethod - 不能关闭数据库连接: " + sqlex2.toString());

　　}

　　}

　　if (out != null) {

　　try {

　　out.close();

　　}

　　catch(IOException ioex2)

　　{

　　System.err(this.getClass().getName() + ".mymethod - 不能关闭输出文件" + ioex2.toString());

　　}

　　}

　　}

　　本文的结论不是放之四海皆准的教条，有时常识和经验才是最好的老师。如果你对自己的做法没有百分之百的信心，务必加上详细、全面的注释。

　　另一方面，不要笑话这些错误，不妨问问你自己是否真地彻底摆脱了这些坏习惯。即使最有经验的程序员偶尔也会误入歧途，原因很简单，因为它们确确实实带来了“方便”。所有这些反例都可以看作Java编程世界的恶魔，它们美丽动人，无孔不入，时刻诱惑着你。也许有人会认为这些都属于鸡皮蒜毛的小事，不足挂齿，但请记住：勿以恶小而为之，勿以善小而不为。

单表继承映射

  每棵类继承树使用一个表。

    映射文件Extends.hbm.xml。

 因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：

（一）父类用普通的<class>标签定义

（二）在父类中定义一个discriminator，即指定这个区分的字段的名称和类型

        如：<discriminator column=”XXX” type=”string”/>

（三）子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：

      1.Subclass标签的name属性是子类的全路径名；

      2.在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）的值；

      3.Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。 当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值是父类的全路径名称。

      4.子类的其它属性，像普通类一样，定义在subclass标签的内部。

具体表继承映射

  每个具体类一张表。（同上例）

映射文件Extends.hbm.xml。

这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：

（一）父类用普通<class>标签定义即可；

（二）子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：

      1.Union-subclass标签不再需要包含key标签（与joined-subclass不同）。

      2.Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass标签中，添加extends属性，里面的值是父类的全路径名称。

     3.子类的其它属性，像普通类一样，定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所有属性的映射字段。

注意：在保存对象的时候id不能重复（不能使用数据库的自增方式生成主键）

类表继承映射

  每个类一张表。（同上例）

映射文件Extends.hbm.xml。

  这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。实现这种策略的时候，有如下步骤：

（一）父类用普通的<class>标签定义即可，父类不再需要定义discriminator字段；

（二）子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：

      1.Joined-subclass标签的name属性是子类的全路径名

      2．Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。

        如：<key column=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。

      3.Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass标签中，添加extends属性，里面的值是父类的全路径名称。

      4.子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。

1、windows->Preferences...打开"首选项"对话框，左侧导航树，导航到general->Workspace，右侧Text file encoding，选择Other，改变为 utf-8(必须小写)，以后新建立工程其属性对话框中的Text file encoding即为UTF-8。

2、windows->Preferences...打开"首选项"对话框，左侧导航树，导航到general->Content Types，右侧Content Types树，点开Text，选择 Java Source File，在下面的Default encoding输入框中输入UTF-8，点Update，则设置Java文件编码为UTF-8。然后设置jsp、js、css等类型的Default encoding，设置方式同Java Source File。

3.windows->Preferences...打开"首选项"对话框，左侧导航树，导航到MyEclipse->Files and Editors->JSP,把Encoding改为UTF-8

1、java.lang包下的80％以上的类的功能的灵活运用。

2、java.util包下的80％以上的类的灵活运用，特别是集合类体系、正规表达式、时间、属性、和Timer.

3、java.io包下的60％以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合。

4、java.math包下的100％的内容。

5、java.net包下的60％以上的内容，对各个类的功能比较熟悉。

6、java.text包下的60％以上的内容，特别是各种格式化类。

7、熟练运用JDBC.

8、java.security包下40％以上的内容，如果对于安全没有接触的话根本就不可能掌握java.

9、AWT的基本内容，包括各种组件事件、监听器、布局管理器、常用组件、打印。

10、Swing的基本内容，和AWT的要求类似。

11、XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。

 在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这 就像在日常生活中，从商店购买了某样物品后，如果有用，就一直保留它，否则就把它扔到垃圾箱，由清洁工人收走。一般说来，如果物品已经被扔到垃圾箱，想再 把它捡回来使用就不可能了。

        但有时候情况并不这么简单，你可能会遇到类似鸡肋一样的物品，食之无味，弃之可惜。这种物品现在已经无用了，保留它会占空间，但是立刻扔掉它也不划算，因 为也许将来还会派用场。对于这样的可有可无的物品，一种折衷的处理办法是：如果家里空间足够，就先把它保留在家里，如果家里空间不够，即使把家里所有的垃 圾清除，还是无法容纳那些必不可少的生活用品，那么再扔掉这些可有可无的物品。从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。这四种级别由高到低依次为：强引用、软引用、弱引用和虚引用。

1．强引用

　　本章前文介绍的引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当内存空 间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

2．软引用（SoftReference）

　　如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

3．弱引用（WeakReference）

　　如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程， 因此不一定会很快发现那些只具有弱引用的对象。 弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

4．虚引用（PhantomReference）

　　"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃 圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是 否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。

1.float类型
float列类型默认长度查不到结果，必须指定精度，
比如 num  float,  insert into  table (num) values (0.12); select  * from table where num=0.12的话，empty set。
num float(9,7),  insert into  table (num) values (0.12); select  * from table where num=0.12的话会查到这条记录。

mysql> create table tt
    -> (
    -> num  float(9,3)
    -> );
Query OK, 0 rows affected (0.03 sec)

mysql> insert into tt(num)values(1234567.8);
ERROR 1264 (22003): Out of range value for column 'num' at row 1
注：超出字段范围，无法插入

mysql> insert into tt(num)values(123456.8);
Query OK, 1 row affected (0.00 sec)

mysql> select  * from  tt;
+------------+
| num        |
+------------+
| 123456.797 |
+------------+
1 row in set (0.00 sec)
注：小数位数不够，自动补齐，但是存在一个问题就是如上的近似值。

mysql> insert into tt(num)values(123456.867);
Query OK, 1 row affected (0.04 sec)

mysql> select * from   tt;
+------------+
| num        |
+------------+
| 123456.797 |
| 123456.797 |
| 123456.867 |
+------------+
3 rows in set (0.00 sec)

mysql> select  * from tt where  num=123456.867;
+------------+
| num        |
+------------+
| 123456.867 |
+------------+
1 row in set (0.00 sec)

mysql> insert into tt(num)values(2.8);
Query OK, 1 row affected (0.04 sec)

mysql> select * from   tt;
+------------+
| num        |
+------------+
| 123456.797 |
| 123456.797 |
| 123456.867 |
|      2.800 |
+------------+
4 rows in set (0.00 sec)

mysql> select  * from tt where  num=2.8;
+-------+
| num   |
+-------+
| 2.800 |
+-------+
1 row in set (0.00 sec)

mysql> insert into tt(num)values(2.888888);
Query OK, 1 row affected (0.00 sec)

mysql> select  * from  tt;
+------------+
| num        |
+------------+
| 123456.797 |
| 123456.797 |
| 123456.867 |
|      2.800 |
|      2.889 |
+------------+
5 rows in set (0.00 sec)
注：小数位数超了，自动取近似值。

--------------------------------------------------------------------------------------

2.double类型

mysql> create table tt(
    -> num  double(9,3)
    -> );
Query OK, 0 rows affected (0.02 sec)

mysql> insert into tt(num) values(234563.9);
Query OK, 1 row affected (0.00 sec)

mysql> select * from  tt;
+------------+
| num        |
+------------+
| 234563.900 |
+------------+
1 row in set (0.00 sec)

mysql> insert into tt(num) values(2345623.2);
ERROR 1264 (22003): Out of range value for column 'num' at row 1
mysql> insert into tt(num) values(234563.2);
Query OK, 1 row affected (0.00 sec)

mysql> select  * from  tt;
+------------+
| num        |
+------------+
| 234563.900 |
| 234563.200 |
+------------+
2 rows in set (0.00 sec)

mysql> insert into tt(num) values(2.8);
Query OK, 1 row affected (0.00 sec)

mysql> select  * from tt;
+------------+
| num        |
+------------+
| 234563.900 |
| 234563.200 |
|      2.800 |
+------------+
3 rows in set (0.00 sec)

FLOAT(M,D)或REAL(M,D)或DOUBLE PRECISION(M,D)。这里，“(M,D)”表示该值一共显示M位整数，其中D位位于小数点后面。
例如，定义为FLOAT(7,4)的一个列可以显示为-999.9999。MySQL保存值时进行四舍五入，因此如果在FLOAT(7,4)列内插入999.00009，近似结果是999.0001。

所谓编程达人，就是工作时要用多个显示屏幕，甚至多台计算机的人

在他们眼里，一个显示器，再大都是小的，哪里有两个显示器用得爽，感觉好

但弱水三千只取一瓢饮，多的时候还是只看一个显示器，这时另一个显示器(下称辅助显示器)怎么办呢？

一般有两个选择：

一是不管他，亮着就亮着呗

二是把辅助显示器电源关了，要用的时候再开

当然，屏保就不成其为选择了，因为它需要时间，其次它会把所有屏幕全部屏保，最后是因为它是自动的，就象汽车，自动挡没有手动挡那么爽

利弊自己体会，以过来人的感觉说一下：

前者，倒是方便，只是时间长了，眼睛难受，一直有两个高亮度的屏幕在距离你头部几十CM的地方亮着，闪烁着，会不会导致头晕就看你体质而定了。

后者，有点麻烦，有时候找电源开关还得换下脑筋

不才区区在下，自己归于编程达人一类，自己发现这个需求，所以就编了个小软件

运行时有两种状态，一种是黑辅助屏，一种是在托盘显示图标，即世界还是正常的。

  学习web这块儿的知识已经有一段儿时间了，最基础也是最常用的便是HTML标签。今天便对HTML知识进行一个小节。

       HTML，超文本标记语言，即Hypertext Markup Language，是用于描述网页文档的一种标记语言。HTML是一种规范，一种标准，它通过标记符号来标记要显示的网页中的各个部分。它功能强大，具有简易性，可扩展性，平台无关性三大特点，支持不同数据格式的文件镶入，这也是万维网盛行的原因。

一、总结图

二、标签解析

三、总结

        HTML的知识非常重要，它是我们学习以后知识的基础。精确掌握这一部分知识，对我们无疑是非常必要的。

Sql注入.

简介.

我们很容易从网上查找到sql注入的定义: 就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意的SQL命令,很容易遭到SQL注入式攻击.

用户可以提交一段数据库的查代码,根据程序返回结果,获得一些敏感的信息或是控制整个服务器.sql注入就发生了.

当然我们要魔高一尺,道高一丈.

防止sql注入:

  永远不要信任用户的输入，对用户的输入进行校验，可以通过正则表达式，或限制长度；对单引号和双 - - (在数据库中认为是数据库语句的连接)进行转换等.

  永远不要动态拼接sql,可以使用参数化的sql或者直接使用存储过程来进行数据查询存取.

   永远不要使用管理员权限的数据库的连接,为每个应用使用单独的权限书库连接.

  不要把机密的信息直接存放,加密.

  应用的异常信息应该处仅少量的提示,最好使用自定义的错误信息对原始的错误进行封装.

  采用软件和有效的网站平台来检测sql注入.

实例.(用参数化的sql进行插入来防止Sql注入)

向数据库的新闻类别表（category）通过字符串拼接的方法插入一条语句。

插入函数的代码.

我们在调试中可以看到传入数据库中的sql语句。

Ctrl+F5我们不调试直接执行，或是我们把此sql语句复制在查询分析器中执行。界面中我们可以看到。

让我们对插入数据库的插入代码修改，用参数传递来代替数据库字符串的拼接。

在SQLHelper加上个ExecuteQuery(string sql ,sqlParam[] paras)的重载.

DOM文档对象模型（Document Object Model，DOM）是一种用于HTML和XML文档的编程接口。它给文档提供了一种结构化的表示方法，可以改变文档的内容和呈现方式。

DOM 被分为不同的部分（核心、XML及HTML）和级别（DOM Level 1/2/3）：

Core DOM

定义了一套标准的针对任何结构化文档的对象

XML  DOM

定义了一套标准的针对 XML 文档的对象

HTML DOM

定义了一套标准的针对 HTML 文档的对象。

JavaScript是一种能让你的网页更加生动活泼的程式语言，也是目前网页中设计中最容易学又最方便的语言。

Dom和JavaScript的关系就像是C#语言和.Ｎet的关系一样

通过 JavaScript，你可以操作DOM来重构整个 HTML 文档。您可以添加、移除、改变或重排页面上的项目。

网上看到一篇博文，是一位原网易的产品总监辞职进行创业。他针对如果大公司抄袭自己的话如何来应对。

整篇文章通过分析大公司中的各种弊端，来确定创业型公司的优点和长处。通过这篇文章一些想要创业的同学会获得一些信心和动力。

不过我个人感觉，如果以前在大公司里遇到的问题的根源是自身的毛病话，即使换个环境也不会自动消失的。

很多人总是会抱怨环境不好，时机不好，境遇不好。而实际很多困境或难题是自己造成的。希望大家共勉。

原文如下：

java.lang.ClassNotFoundException: javax.transaction.UserTransaction

解决办法：
到 http://java.sun.com/products/jta/ 下载
Java Transaction API classes 的zip包，解压然后用命令将jta-1_1-classes下都javax文件夹压缩成jar

命令:jar cf jta.jar javax 
生成一个jta.jar文件，把这个文件添加到classpath

或者直接在Spring  lib中查找，复制添加到classpath