lym的博客

Linux(Ubuntu)基础及其基本命令介绍

2013-09-10T00:00:00+00:00

Linux(Ubuntu)基础及其基本命令介绍

Linux 的灵感源自 1969 年就出现的 Unix 操作系统，时至今日该系统仍被广泛使用，并在不断发展中。 Unix 背后的许多设计惯例也同样存在于 Linux 中，对系统基本原理的理解至关重要。 Unix 最初主要使用命令行界面，这在 Linux 中也得到了保留。也就是说，图形用户界面及其窗口、图标、菜单等都构建在基本的命令行界面之上。更进一步，这也意味着在命令行里可以十分便捷的管理和访问 Linux 的文件系统。

1 目录和文件系统

Linux 和 Unix 文件系统被组织成一个有层次的树形结构。文件系统的最上层是 /，或称为 根目录。在 Unix 和 Linux 的设计理念中，一切皆为文件——包括硬盘、分区和可插拔介质。这就意味着所有其它文件和目录（包括其它硬盘和分区）都位于根目录中。例如：/home/jebediah/cheeses.odt 给出了正确的完整路径，它指向 cheeses.odt 文件，而该文件位于 jebediah 目录下，该目录又位于 home 目录，最后，home 目录又位于根(/) 目录下。在根 (/) 目录下，有一组重要的系统目录，在大部分 Linux 发行版里都通用。直接位于根 (/) 目录下的常见目录列表如下：

/bin	重要的二进制 (binary) 应用程序
/boot	启动 (boot) 配置文件
/dev	设备 (device) 文件
/etc	配置文件、启动脚本等 (etc)
/home	本地用户主 (home) 目录
/lib	系统库 (libraries) 文件
/lost+found	在根 (/) 目录下提供一个遗失+查找(lost+found) 系统
/media	挂载可移动介质 (media)，诸如 CD、数码相机等
/mnt	挂载 (mounted) 文件系统
/opt	提供一个供可选的 (optional) 应用程序安装目录
/proc	特殊的动态目录，用以维护系统信息和状态，包括当前运行中进程 (processes) 信息。
/root	root (root) 用户主文件夹，读作“slash-root”
/sbin	重要的系统二进制 (system binaries) 文件
/sys	系统 (system) 文件
/tmp	临时(temporary)文件
/usr	包含绝大部分所有用户(users)都能访问的应用程序和文件
/var	经常变化的(variable)文件，诸如日志或数据库等

2 常用命令

1. 切换到 root 用户，输入“sudo -i”或“sudo su -”, 退出“exit”

2. pwd 显示当前目录， pwd = print working directory

3. ls 列出目录下当前文件

4. cp 复制文件/目录 cp (源文件或目录) (目标文件或目录)

cp -r  复制文件夹 包括子目录和文件

5. rm 删除文件/目录可以删除文件

rm -rf  删除目录包含子目录和文件
rmdir  删除空文件夹

6. mv 移动或重命名文件

7. cd 进入目录

cd / 		#进入根目录 

cd 或 cd ~ 	#进入用户的 home 目录

cd - 		#进入上次访问的目录 (相当于 back) 
cd ..  		#进入上级目录

8. man 显示某个命令的 manual

9. df 显示文件系统空间信息

df -h  	#用 M 和 G 做单位显示文件系统空间信息 -h 意思是 human-readable

10. du 显示目录的空间使用信息

du -sh /media/floppy	#-s 意思 summary  -h 意思 human-readable

11. ifconfig 显示系统的网络

12. locate 命令会在您的计算机里搜索您指定的任意文件。它使用您系统中的文件索引以便进行快速查找：运行命令 updatedb 可以更新该索引。每天您一开机，该命令便会（在合适的时机）自动运行。运行该命令需要具备管理员权限.

13. Ubuntu卸载编译的软件

cd 源代码目录
make clean
./configure
make uninstall

14. 查找命令

1）find

find是最常见和最强大的查找命令，你可以用它找到任何你想找的文件。

find的使用格式如下：

　　$ find <指定目录> <指定条件> <指定动作>

　　- <指定目录>：所要搜索的目录及其所有子目录。默认为当前目录。

　　- <指定条件>：所要搜索的文件的特征。

　　- <指定动作>：对搜索结果进行特定的处理。

如果什么参数也不加，find默认搜索当前目录及其子目录，并且不过滤任何结果（也就是返回所有文件），将它们全都显示在屏幕上。

find的使用实例：

　　$ find . -name ‘my*’

搜索当前目录（含子目录，以下同）中，所有文件名以my开头的文件。

　　$ find . -name ‘my*’ -ls

搜索当前目录中，所有文件名以my开头的文件，并显示它们的详细信息。

　　$ find . -type f -mmin -10

搜索当前目录中，所有过去10分钟中更新过的普通文件。如果不加-type f参数，则搜索普通文件+特殊文件+目录。

2）locate

locate命令其实是”find -name”的另一种写法，但是要比后者快得多，原因在于它不搜索具体目录，而是搜索一个数据库（/var/lib/locatedb），这个数据库中含有本地所有文件信息。Linux系统自动创建这个数据库，并且每天自动更新一次，所以使用locate命令查不到最新变动过的文件。为了避免这种情况，可以在使用locate之前，先使用updatedb命令，手动更新数据库。

locate命令的使用实例：

　　$ locate /etc/sh

搜索etc目录下所有以sh开头的文件。

　　$ locate ~/m

搜索用户主目录下，所有以m开头的文件。

　　$ locate -i ~/m

搜索用户主目录下，所有以m开头的文件，并且忽略大小写。

3）whereis

whereis命令只能用于程序名的搜索，而且只搜索二进制文件（参数-b）、man说明文件（参数-m）和源代码文件（参数-s）。如果省略参数，则返回所有信息。

whereis命令的使用实例：

　　$ whereis grep

4）which

which命令的作用是，在PATH变量指定的路径中，搜索某个系统命令的位置，并且返回第一个搜索结果。也就是说，使用which命令，就可以看到某个系统命令是否存在，以及执行的到底是哪一个位置的命令。

which命令的使用实例：

　　$ which grep

5）type

type命令其实不能算查找命令，它是用来区分某个命令到底是由shell自带的，还是由shell外部的独立二进制文件提供的。如果一个命令是外部命令，那么使用-p参数，会显示该命令的路径，相当于which命令。

type命令的使用实例：

　　$ type cd

系统会提示，cd是shell的自带命令（build-in）。

　　$ type grep

系统会提示，grep是一个外部命令，并显示该命令的路径。

　　$ type -p grep

加上-p参数后，就相当于which命令。(注意：如果是内置命令的话，没有输出)

　　$ type -P grep

-P参数代表强制搜索，此时内置命令也会有输出

15. vim编辑

a. ctrl+f下翻页(forward)、ctrl+b上翻页(backwards)、M将光标移动的该页中部(Middle)、gg回到文件顶部、G回到文件底部、hjkl移动光标

b. vim查找命令：命令模式下，按‘/’，然后输入要查找的字符，Enter。

c. 手动重加载文件的命令是 :e! (以前是退出编辑重新打开，用这个的话方便多了)

d. 清空文件内容(3种)：在命令模式下，首先执行gg，这里是跳至文件首行，再执行dG，这样就清空了整个文件！还有一种方法就要退出VIM，然后使用echo » file。最后一种是删除了这个文件再新建一个就是了

16. 查看当前时间

test@lym406365619:~$ date
Tue Jan 20 10:22:53 CST 2014

17. Linux时间同步 – ntpdate

sudo ntpdate -u pool.ntp.org
#pool.ntp.org是一组授时服务器虚拟集群

时间同步之后，如果没有设置时间区域，默认的时区是UTC。把时区改成北京时间，执行这面的命令：

cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime

参考

http://wiki.ubuntu.org.cn

Ubuntu server版本忘记用户密码的解决办法

2013-08-31T00:00:00+00:00

Ubuntu server版本忘记用户密码的解决办法

好久没有登录VirtualBox中的Ubuntu虚拟机，今天登录了一下，发现自己竟然忘记了用户的密码，root用户的密码也忘了，于是上网找了几篇文章看了一下，终于顺利解决了。我用的是Ubuntu-server-12.04版本，下面介绍一下解决方法。

1 解决方法

1.1 启动虚拟机，进入到GRUB，用键盘“↑”或“↓”键选择第二行（Ubuntu, with Linux 3.3.0-23-generic (recovery mode)）

1.2 按键盘“e”键进入编辑页面（注意不是回车）

1.3 把ro recovery nomodeset改成rw single init=/bin/bash

1.4 按键盘Ctrl+x两个键，进入单用户模式

1.5 修改用户的密码

cat /etc/shadow     # 查看当前用户（如果知道用户名，可以忽略）
passwd "username"   # 用户名为username，引号记得加上

然后提示输入用户密码，输入两边即可。

重启后即可登录。

2 修改root用户密码

用户登录后，执行以下命令：

sudo passwd root # 获得root权限进行修改
# 输入两次密码，修改完成

参考

http://blog.csdn.net/zonelan/article/details/7968193

http://ljhzzyx.blog.163.com/blog/static/383803122010430114655408/

Bala新闻

2013-08-22T00:00:00+00:00

Bala新闻

Bala出游

2013-08-10T00:00:00+00:00

Bala出游

ExtJS列表中根据行记录来控制单元格是否可以编辑

2013-07-30T00:00:00+00:00

ExtJS列表中根据行记录来控制单元格是否可以编辑

ExtJS中，对Grid列表进行编辑，可以通过加入ExtJS列表插件来实现（在grid->columns->column增加editor属性），控制列表中的哪些字段可以编辑比较容易实现。不过根据点击记录的内容来控制是否可以编辑，就稍微复杂一些了，下面简单介绍一下。

1 说明

Use beforeedit event:

grid.on('beforeedit', function(editor, e) {
  if (e.colIdx === 0 && e.record.get('status') == 4)
    return false;
});

UPDATE

The solution above is not working for rowEditor. However you can make needed field to be disabled on beforeedit. To do that you should be able to access rowediting plugin. Assign pluginId to plugin:

plugins: [
    Ext.create('Ext.grid.plugin.RowEditing', {
        clicksToEdit: 1,
        pluginId: 'rowEditing'
    })
],

Now just disable needed field if some conditions are met:

grid.on('beforeedit', function(e) {
    if (e.record.get('status') == 4)
        grid.getPlugin('rowEditing').editor.form.findField('neededColumnDataIndex').disable();
    else
        grid.getPlugin('rowEditing').editor.form.findField('neededColumnDataIndex').enable();
});

Here is demo (try to edit first row).

2 demo

Ext.create('Ext.data.Store', {
    storeId:'simpsonsStore',
    fields:['name', 'email', 'phone'],
    data: [
        {"name":"Lisa", "email":"lisa@simpsons.com", "phone":"555-111-1224"},
        {"name":"Bart", "email":"bart@simpsons.com", "phone":"555--222-1234"},
        {"name":"Homer", "email":"home@simpsons.com", "phone":"555-222-1244"},
        {"name":"Marge", "email":"marge@simpsons.com", "phone":"555-222-1254"}
    ]
});

var grid = Ext.create('Ext.grid.Panel', {
    title: 'Simpsons',
    store: Ext.data.StoreManager.lookup('simpsonsStore'),
    columns: [
        {header: 'Name',  dataIndex: 'name', editor: 'textfield'},
        {header: 'Email', dataIndex: 'email', flex:1,
            editor: {
                xtype: 'textfield',
                allowBlank: false
            }
        },
        {header: 'Phone', dataIndex: 'phone'}
    ],
    selType: 'rowmodel',
    plugins: [
        Ext.create('Ext.grid.plugin.RowEditing', {
            clicksToEdit: 1,
            pluginId: 'rowEditing'
        })
    ],
    height: 200,
    width: 400,
    renderTo: Ext.getBody()
});

grid.on('beforeedit', function(e) {
    if (e.record.get('phone') == "555-111-1224")
        grid.getPlugin('rowEditing').editor.form.findField('name').disable();
    else
        grid.getPlugin('rowEditing').editor.form.findField('name').enable();
});

参考

http://stackoverflow.com/questions/7679364/extjs-4-rowediting-disable-edit-on-one-column-based-on-record

Java中抽象类和接口的区别

2013-07-15T00:00:00+00:00

Java中抽象类和接口的区别

在Java语言中，抽象类（abstract class）和接口（interface）是支持抽象类定义的两种机制。虽然两者在对于抽象类定义的支持方面有很大的相似性，甚至可以互相替换。其实，搞清楚两者的区别还是挺重要的，对于它们的选择甚至反映出对于问题领域本质的理解，对于设计意图的理解是否正确、合理。本文将对两者之间的区别进行分析。

1 抽象类简介

abstract class和interface在Java语言中都是用来描述抽象类（本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？

在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。

在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。

2 从语法定义层面看abstract class和interface

在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。

使用abstract class的方式定义Demo抽象类的方式如下：

abstract class Demo {
	abstract void method1();
	abstract void method2();
}

使用interface的方式定义Demo抽象类的方式如下：

interface Demo {
	void method1();
	void method2();
}

在abstract class方式中，可以有自己的数据成员，也可以有非abstract的成员方法，而在interface方式的实现中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的abstract class。

3 从编程的角度来看abstract class和interface

从编程的角度来看，abstract class和interface都可以用来实现“design by contract”的思想。但是在具体的使用上面还是有一些区别的。

首先，abstract class在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系(因为Java不支持多继承)。但是，一个类却可以实现多个interface。

其次，在abstract class的定义中，我们可以赋予方法的默认行为。但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会增加一些复杂性，有时会造成很大的麻烦。

4 从设计理念层面看abstract class和interface

abstract class在Java语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在“is-a”关系，即父类和派生类在概念本质上应该是相同的。对于interface来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将通过一个简单的实例进行说明。

考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：

使用abstract class方式定义Door：

abstract class Door {
	abstract void open();
	abstract void close();
}

使用interface方式定义Door：

interface Door {
	void open();
	void close();
}

其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）？下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。

解决方案一

简单的在Door的定义中增加一个alarm方法，如下：

abstract class Door {
	abstract void open();
	abstract void close();
	abstract void alarm();
}

或者

interface Door {
	void open();
	void close();
	void alarm();
}

那么具有报警功能的AlarmDoor的定义方式如下：

class AlarmDoor extends Door {
	void open() {/*...*/}
	void close() {/*...*/}
	void alarm() {/*...*/}
}

或者

class AlarmDoor implements Door {
	void open() {/*...*/}
	void close() {/*...*/}
	void alarm() {/*...*/}
}

这种方法违反了面向对象设计中的一个核心原则ISP(Interface Segregation Principle)，在Door的定义中把Door概念本身固有的行为方法和另外一个概念“报警器”的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为“报警器”这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。

解决方案二

既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用abstract class方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另一个概念使用interface方式定义。

显然，由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

如果两个概念都使用interface方式来定义，那么就反映出两个问题：

1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？

2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。

如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在Java语言中表示一种继承关系，而继承关系在本质上是“is-a”关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：

abstract class Door {
	abstract void open();
	abstract void close();
}

interface Alarm {
	void alarm();
}

class Alarm Door extends Door implements Alarm {
	void open() {/*...*/}
	void close() {/*...*/}
	void alarm() {/*...*/}
}

这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract class表示的是“is-a”关系，interface表示的是“like-a”关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。

5 小结

1. abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

2. 在abstract class中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。

3. abstract class和interface所反映出的设计理念不同。其实abstract class表示的是“is-a”关系，interface表示的是“like-a”关系。

4. 实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

5. 接口中定义的变量默认是public static final型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

6. 抽象类中的变量默认是friendly型，其值可以在子类中重新定义，也可以重新赋值。

7. 接口中的方法默认都是public、abstract类型的。

参考

http://dev.yesky.com/436/7581936.shtml

《Java Web开发实战1200例》实用案例之第五章JavaBean技术

2013-07-02T00:00:00+00:00

《Java Web开发实战1200例》实用案例之第五章JavaBean技术

1 字符串转换成数组

将字符串转换为数组也是开放中常用的技术，如用户在某个表单页中选中了复选框，在处理这些选中的内容时，需要获得复选框的所选中的内容，此时需要JavaScript方法将所有选中的内容累加，然后将这个累加后的字符串提交，在服务器端获得该字符串时，就需要将这个包含多个复选框内容的长字符串分解为数组，然后进一步处理。

可以通过String类的split()方法来实现将字符串转换为数组。split()方法包含一个String类型的参数regex，调用时会以regex为字符串的分隔符，将字符串分隔为字符串数组。

2 整型与字符串相互转换

在实际开发过程中，经常需要将整型值转换为字符串。可以使用以下3中渐变的方法：

String.valueOf()

Integer.toString()

Integer.valueOf().toString();

将字符串转型为整型，主要使用的是Integer类的parseInt()方法和valueOf()方法。它们都可以接收一个String类型的参数。

3 数据验证（也可以使用正则表达式）

3.1 判断字符串是否以指定字符开头

public boolean startsWith(String prefix)

3.2 检查字符串是否包含英文字母

应用String类的toCharArray()方法。首先通过该方法将指定的字符串转换为字符数组，然后循环该字符数组。其中大写英文字母的ASCII码范围在65~90之间，小写的在97~112之间。

3.3 判断用户输入的日期是否为当前日期

主要应用java.util.Calendar类实现。

Calendar now = Calendar.getInstance();	//创建一个当前时间的Calendar对象
int year =  now.get(now.YEAR);	//获得当前时间的年份
int month = now.get(now.MONTH) + 1;	//获得当前时间的月份。默认的月份是从0开始的，所以需要加1
int date = now.get(now.DAY_OF_MONTH);	//获得当前时间的日
int hour = now.get(now.HOUR_OF_DAY);	//获得当前时间的小时
int minute = now.get(now.MINUTE);	//获得当前时间的分钟
int second = now.get(now.SECOND);	//获得当前时间的秒

4 日期时间处理

###4.1 将指定日期字符串转换为Calendar对象

主要应用格式化日期短时间的java.text.SimpleDateFormat类，实现步骤如下：

//创建一个“yyyy-mm-dd”格式的格式化对象
SimpleDataFormat format = new SimpleDateFormat("yyyy-MM-dd");
//通过SimpleDateFormat对象的parse()方法将制定字符串转换为Date对象
Date date = format.parse("2013-07-01");
//通过Calendar对象的setTime()方法将Date对象转换为Calendar对象
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);

4.2 获得系统当前时间的字符串格式

通过java.util.Calendar类以及java.util.Date类来获得系统的当前时间

使用Calendar类，要通过该类对象的get()方法获得时间中的年、月、日、小时、分钟和秒，然后将这些值组成一个字符串。

使用Date类，可以通过java.text.SimpleDateFormat类将一个Date对象格式化为指定格式的日期时间字符串。代码如下：

Date date = new Date();
SimpleDataFormat format = new SimpleDateFormat("yyyy-MM-dd hh-mm-ss");
String dateStr = format.format(date);

4.3 计算出两个日期相差的天数

主要应用Calendar对象中的getTimeMillis()方法，此方法返回一个long型的时间值，以毫秒为单位。首先获得两个日期对象的long类型的时间值，然后这两个值相减之后再除以一天的毫秒值(1000*60*60*24)，得到的值取整即两个日期相差的天数。

5 输出分页导航的方法

在实际开发过程中，很多的功能模块显示数据的部分都需要分页显示，而且分页部分的HTML代码都是相同的，为了提高开发效率以及便于维护，可以将这部分分页导航的代码封装在JavaBean中。

新建名为Page的JavaBean类，该类用于封装分页导航的代码。

package info.luyueming.bean;

public class Page {
	private int pageSize = 10; // 每页显示的记录数
	private int currentPage = 1; // 当前页
	private int totalPage = 0; // 总页数
	private int totalRows = 0; // 总记录数
	private boolean hasBefore = false; // 是否有上一页
	private boolean hasNext = false; // 是否有下一页
	private String linkHTML = ""; // 用于保存分页导航的HTML代码
	private String pageURL; // 具体的链接地址

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	public int getCurrentPage() {
		return currentPage;
	}

	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
	}

	public int getTotalPage() {
		totalPage = ((totalRows + pageSize) - 1) / pageSize;	// 根据数据总数和每页显示的记录数算出总页数
		return totalPage;
	}

	public int getTotalRows() {
		return totalRows;
	}

	public void setTotalRows(int totalRows) {
		this.totalRows = totalRows;
	}

	public boolean isHasBefore() {
		return hasBefore;
	}

	public void setHasBefore(boolean hasBefore) {
		this.hasBefore = hasBefore;
	}

	public boolean isHasNext() {
		return hasNext;
	}

	public void setHasNext(boolean hasNext) {
		this.hasNext = hasNext;
	}

	public String getPageURL() {
		return pageURL;
	}

	public void setPageURL(String pageURL) {
		this.pageURL = pageURL;
	}

	// 单击的是首页
	public void firstPage() {
		currentPage = 1; // 当前页的值为1
		this.setHasBefore(false); // 没有上一页
		this.refresh(); // 单击首页时应该设置是否有上一页和下一页
	}

	// 单击的是上一页
	public void beforePage() {
		currentPage--; // 当前页的值减1
		this.refresh(); // 单击上一页时应该设置是否有上一页和下一页

	}

	// 单击的是下一页
	public void nextPage() {
		if (currentPage < totalPage) {
			currentPage++; // 当前页的值加1
		}
		this.refresh(); // 单击下一页时应该设置是否有上一页和下一页
	}

	// 单击的是尾页
	public void lastPage() {
		currentPage = totalPage; // 当前页的值等于总页数
		this.setHasNext(false); // 没有下一页
		this.refresh(); // 单击上一页时应该设置是否有上一页和下一页
	}

	// 判断用户的操作，判断是否有上一页和下一页
	public void refresh() {
		if (totalPage <= 1) { // 总页数小于等于1的情况，没有上一页和下一页
			this.setHasBefore(false);
			this.setHasNext(false);
		} else if (currentPage == 1) { // 当前页为首页，没有上一页，有下一页
			this.setHasBefore(false);
			this.setHasNext(true);
		} else if (currentPage == totalPage) {// 当前页为尾页，没有下一页，有上一页
			this.setHasBefore(true);
			this.setHasNext(false);
		} else {// 除了以上的所有条件，有上一页和下一页
			this.setHasBefore(true);
			this.setHasNext(true);
		}
	}

	// 获得分页导航代码的方法，主要根据是否有上一页和下一页来判断
	public String getLinkHTML() {
		linkHTML += "共" + this.totalRows + "条记录 &nbsp;&nbsp;&nbsp;&nbsp;";
		if (this.hasBefore) {// 如果有上一页，添加上一页的超链接代码
			linkHTML += "<a href='" + this.pageURL + "?currPage=1'>首页</a>";
			linkHTML += "&nbsp;&nbsp;&nbsp;&nbsp;";
			linkHTML += "<a href='" + this.pageURL + "?currPage=" + this.currentPage + "&action=before'>上一页</a>";
			linkHTML += "&nbsp;&nbsp;&nbsp;&nbsp;";
		} else { // 如果没有上一页
			linkHTML += "首页  &nbsp;&nbsp;&nbsp;&nbsp;上一页&nbsp;&nbsp;&nbsp;&nbsp;";
		}
		if (this.hasNext) { // 如果有下一页，添加下一页的超链接代码
			linkHTML += "<a href='" + this.pageURL + "?currPage=" + this.currentPage + "&action=next'>下一页</a>";
			linkHTML += "&nbsp;&nbsp;&nbsp;&nbsp;";
			linkHTML += "<a href='" + this.pageURL + "?currPage=" + this.totalPage + "'>尾页</a>";
			linkHTML += "&nbsp;&nbsp;&nbsp;&nbsp;";
		} else { // 没有下一页
			linkHTML += "下一页  &nbsp;&nbsp;&nbsp;&nbsp;尾页&nbsp;&nbsp;&nbsp;&nbsp;";
		}
		linkHTML += "当前为" + this.currentPage + "/" + this.totalPage + "页";
		return linkHTML;
	}

	public void setLinkHTML(String linkHTML) {
		this.linkHTML = linkHTML;
	}
}

5 窗口与对话框

在网站开发中，经常需要对网站的某个功能的操作给出提示信息的对话框或者弹出一个固定大小窗口，以便于用户正确的使用网站

5.1 打开指定大小的新窗口

使用JavaScript打开一个弹出窗口，可以使用window对象的open()方法或者showModalDialog()方法完成。

showModalDialog()方法的代码如下：

var url="window1.jsp"
window.showModalDialog(url,'window','status=no;dialogWidth=560px;dialogHeight=190px;center=yes;help=no;location=no;');

open()方法如下：

var url="window1.jsp"
window.open(url,'window','status=no,width=560px,height=190px,center=yes,help=no,location=no,menubar=no,toolbar=no');

使用showModalDialog()方法弹出的窗口是模态窗口，不能最小化，只有关闭当前弹出的模态窗口才能操作其他页面。而使用open()方法弹出的更像是一个页面，此时对操作其他页面没有影响，但是在弹出该页面之前会首先弹出一个警告对话框，从而会给网站浏览者带来不必要的操作。

6 总结

本章主要介绍了JavaBean技术的相关应用，有字符串处理、数据验证、日期时间处理、输出实用的HTML代码、窗口与对话框以及对数据库操作的JavaBean。其中日期时间处理是数据库中经常用到的，必须学会Date、Calendar以及字符串三者之间的相互转换；数据验证这一节可以使用正则表达式来代替实现；如何学会使用分页也是本章的一个重点。

使用JavaBean实现小写金额到大写金额的转换

2013-07-01T00:00:00+00:00

使用JavaBean实现小写金额到大写金额的转换

1 新建名为StringUtil的JavaBean类；

package info.luyueming.bean;

public class StringUtil {
	private String money; // 转换之前的数字金额
	private String submoneyCN[] = { "", "拾", "佰", "仟" }; // 表示数字位数的数组
	private String numberCNN[] = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" }; // 大写数字的数组

	public void setMoney(String money) {
		this.money = money;
	}

	public String getMoney() {
		return convert(this.money);
	}

	/**
	 * 转换数字金额为大写金额
	 * 
	 * @return 返回转换后的大写金额
	 */
	public String convert(String money) {
		String formatCN = "";
		int point = money.indexOf("."); // 判断字符串是否包含小数点
		if (point != -1) {
			String money1 = money.substring(0, point); // 小数点之前的部分
			String money1_1 = (new StringBuffer(money1).reverse()).toString();// 字符串倒序
			String money2 = money.substring(point + 1); // 小数点之后的部分
			if (money2.length() < 2) { // 如果小数点后的部分少于两位，用"0"补齐
				if (money2.length() == 0)
					money2 = "00";
				else
					money2 += "0";
			} else
				// 如果小数点后的位数大于2位，则只前2位
				money2 = money.substring(point + 1, point + 3);
			int len = money1_1.length(); // 字符串反转之后，小数点之前的字符位数
			int pos = len - 1;
			String sigle = "";
			boolean allhavenum = false;
			boolean havenum = false;
			boolean mark = false; // 设置一个开关变量，若当前数为"0"，将该值设为true；不为"0"时设为false
			/** 以下代码为读出小数点左面的部分 */
			while (pos >= 0) {
				sigle = money1_1.substring(pos, pos + 1);// 截取1位数字，比如数字1234.56,将左侧的字符串反转，值为4321，则截取的值为1

				/**
				 * 读取“亿单元”的代码。 假设读取10024531042.34。 小数点左面反转后为：24013542001
				 * pos的初始值为10 mark的初始值为false havenum的初始值为false
				 * */
				if (pos >= 8 && pos < 12) {
					if (!sigle.equals("0")) { // 如果当前值不为"0"
						if (!mark) { // 如果当前值的前一位数不为"0"
							formatCN += numberCNN[Integer.parseInt(sigle)]
									+ submoneyCN[pos % 4];
						} else { // 如果当前值不为"0"，但该值的前一位数为"0"
							if (allhavenum) { // 如果在当前值之前有不为"0"的数字出现。该条件用来处理用户输入的如：0012.34的数值
								formatCN += "零";
							}
							formatCN += numberCNN[Integer.parseInt(sigle)] + submoneyCN[pos % 4];
							mark = false;
						}
						havenum = true;
						allhavenum = true; // 变量allhavenum表示小数点左面的数中是否有不为"0"的数字；true表示有，false表示无
					} else { // 如果当前值为"0"
						mark = true;
					}
					if (pos % 4 == 0 && havenum) { // 如果当前数字为该单元的最后一位，并且该单元中有不为"0"的数字出现
						formatCN += "亿";
						havenum = false;
					}
				}
				/** 读取“万单元”的代码 */
				if (pos >= 4 && pos < 8) {
					if (!sigle.equals("0")) {
						if (!mark)
							formatCN += numberCNN[Integer.parseInt(sigle)] + submoneyCN[pos % 4];
						else {
							if (allhavenum) {
								formatCN += "零";
							}
							formatCN += numberCNN[Integer.parseInt(sigle)] + submoneyCN[pos % 4];
							mark = false;
						}
						havenum = true;
						allhavenum = true;
					} else {
						mark = true;
					}
					if (pos % 4 == 0 && havenum) {
						formatCN += "万";
						havenum = false;
					}
				}
				/** 读取“个、十、百、千”的代码 */
				if (pos >= 0 && pos < 4) {
					if (!sigle.equals("0")) {
						if (!mark)
							formatCN += numberCNN[Integer.parseInt(sigle)] + submoneyCN[pos % 4];
						else {
							if (allhavenum) {
								formatCN += "零";
							}
							formatCN += numberCNN[Integer.parseInt(sigle)] + submoneyCN[pos % 4];
							mark = false;
						}
						havenum = true;
						allhavenum = true;
					} else {
						mark = true;
					}
				}
				pos--;
			}
			/** 碰到小数点时的读法 */
			if (allhavenum) // 如：00.34就不能读为:元3角4分.变量allhavenum表示小数点左面的内容中是否有数字出现
				formatCN += "元";
			else
				// 如果小数点左面的部分都为0如：00.34应读为：零元3角4分
				formatCN = "零元";
			/** 以下代码为读出小数点右面的部分 */
			if (money2.equals("00"))
				formatCN += "整";
			else {
				/** 读出角,如120.34读为：1佰2拾元零3角4分；123.04读为：1佰2拾3元零4分 */
				if (money2.startsWith("0") || (allhavenum && money1.endsWith("0"))) {
					formatCN += "零";
				}
				if (!money2.startsWith("0")) {
					formatCN += numberCNN[Integer.parseInt(money2.substring(0,1))] + "角";
				}
				// 读出分，如：12.30读1拾2元3角零分
				formatCN += numberCNN[Integer.parseInt(money2.substring(1))] + "分";
			}
		} else {
			formatCN = "输入的格式不正确！格式：888.00";
		}
		return formatCN;
	}
}

2 新建index.jsp页面，用于输入数字金额；

关键代码如下：

<form action="convert.jsp" method="post">
	<table>
		<tr>
			<td align="center" bgcolor="skyblue"> 请输入金额</td>
		</tr>
		<tr height="25">
			<td bgcolor="yellow"> 
				金额：<input type="text" name="money" id="money" />
				<input type="submit" value="转 换">
			</td>
		</tr>
	</table>
</form>

3 新建covert.jsp的处理页，用于获得表单的请求信息，并调用Bean类的方法转换金额。

代码如下：

<%
	String  money=request.getParameter("money");
%>
<jsp:useBean id="strBean" class="info.luyueming.bean.StringUtil"></jsp:useBean>
<jsp:setProperty property="money" name="strBean" value="<%=money%>"/>
<table>
	<tr>
		<td align="center" bgcolor="skyblue"> 转换结果：</td>
	</tr>
	<tr height="25">
		<td bgcolor="yellow"><jsp:getProperty property="money" name="strBean"/></td>
	</tr>
</table>

运行结果如下所示：

4 总结

本实例的实现关键是如何找到其中的算法规律。例如，读取123456789.12这样一个数字，可以将数据以小数点为界限分为两个部分，小数点左侧的数字从各位起每4位组成一个单元，然后想读取个、十、百、千的方法读取各个单元，并加上该单元的单位；小数点右侧的数字可以直接读取。

《Java Web开发实战1200例》实用案例之第四章JSP基础与内置对象

2013-06-30T00:00:00+00:00

《Java Web开发实战1200例》实用案例之第四章JSP基础与内置对象

1 JSP的基本应用

JSP是Java Server Page的缩写，它是Servlet的扩展，是一种基于本文的程序。JSP的特点是HTML代码与Java程序共同存在，在接收到用户请求时，服务器会处理Java代码片段，然后生成处理结果的HTML页再返回给客户端，客户端的浏览器将呈现最终页面效果。

1.1 自定义错误页面

使用JSP中的page指令的errorPage属性自定义错误页面，代码如下：

<%@ page errorPage="error.jsp" %>

其中error.jsp是一个专门负责处理异常的网页。

也可以应用web.xml文件中的error-page参数定义错误页面，应用该参数配置的错误页面将对所有页面有效。

<error-page>
	<error-code>404</error-code>
	<loaction>/error.jsp</loaction>
</error-page>

1.2 在JSP脚本中插入JavaScript代码

在一些网站中添加注册信息是，注册成功后可能需要弹出一个“注册成功”的提示信息窗口，这就需要在JSP脚本中插入JavaScript的alert()方法来实现。

创建用户注册表单页index.jsp，将表单提交到save.jsp，关键代码如下：

<form action="save.jsp" method="post">
	......
</form>

创建save.jsp页面，该页只是为了演示如何在JSP脚本中插入JavaScript代码，并没有真正对表单数据进行处理，代码如下：

<%
	out.println("<script>alert('注册成功！');window.location.href='index.jsp';</script>")
%>

2 JSP的内置对象

JSP提供了request、response、session、application、out、page、config、exception和pageContent9个内置对象。其中request对象、response对象、out对象、page对象、config对象、exception对象和pageContent对象的有效范围是当前页面，而session对象的有效范围是当前会话，即同一个客户端的所有页面；application对象的有效范围是当前应用，只要服务器不关闭，这个对象就有效。

2.1 JSP编程–request

request内置对象表示的是调用JSP页面的请求。通常，request对象是javax.servlet.http.HttpServletRequest接口的一个实例

典型应用：

通过request.getParameter(“paramName”)可以获得form提交过来的参数值

通过request.setAttribute(String name, Object object)进行数据传递

2.2 实现重定向页面

response.sendRedirect(String url)：重定向JSP文件

和<jsp:forward>的区别：

sendRedirect通过客户端发起二次申请，不同的request对象；jsp:forward是同一个request，在服务器内部转发。

2.3 应用session对象实现用户登录

通过session对象可以存储或读取客户相关的信息，如用户名等。方法：

session.setAttribute(String name, Object obj)	//用于将信息保存在session范围内

session.getAttribute(String name)		//获取保存在session范围内的信息

session.invalidate();		//销毁session

3 JSP的自定义标签

JSP设计自定义标签的目的就是为了实现HTML代码的重用。 ###3.1 带标签体的自定义标签

首先了解一下什么是带标签体的标签。

示例：<test:mytag>xxxxx</test:mytag>

说明：以上标签中间的xxxxx即为标签体

javax.servlet.jsp.tagext.TagSupport类，该类实现了Tag接口，用于创建不带标签体的自结束标签，这些标签中可以带属性。

javax.servlet.jsp.tagext.BodyTagSupport类，该类继承了TagSupport，用于创建带标签体的标签。

开发和使用一个JSP自定义标签的过程：

1）开发标记处理类，编译生成class 文件，该类要继承TagSupport 或BodyTagSupport；

2）创建标记库描述符文件*.tld，在该文件中为标记处理类指定标签名、声明标签属性；

3）在JSP中引用标签库；

4）在JSP中使用JSP标签。

本实例主要使用标签体的getBodyContent()方法自定义一个标签，把一段字母按大写输出。

1）创建BodyTagSupport类的实现类TagBody.java。代码如下：

package info.luyueming.bodycontent;

import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyTagSupport;

public class TagBody extends BodyTagSupport {

	public int doEndTag() throws JspException {
		String ct = this.getBodyContent().getString();
		// 获取标签体的代码
		try {
			// 以大写输出
			this.pageContext.getOut().print(ct.toUpperCase());
		} catch (IOException e) {
			e.printStackTrace();
		}
		return EVAL_PAGE;
	}
	
}

2）创建tagbody.tld文件，并放在WEB-INF目录下。代码如下：

<tlib-version>1.0</tlib-version>
<short-name>toUpperCase</short-name>
<tag>
	<name>toupp</name>
	<tagclass>info.luyueming.bodycontent.TagBody</tagclass>
	<bodycontent>JSP</bodycontent>
</tag>

3）创建index.jsp页面。主要代码如下：

<body>
	<toUpperCase:toupp>hello welcome!!!!</toUpperCase:toupp>  	
</body>

并在该jsp页面前加上下面一行，否则会报错。

<%@ taglib uri="/WEB-INF/tagbody.tld"  prefix="toUpperCase"%>

4 总结

这一章主要介绍了JSP的基本应用、JSP九个内置对象、以及JSP的自定义标签三个方面。其中九个内置对象是非常重要的，值得进一步去学习。

《Java Web开发实战1200例》实用案例之第三章HTML/CSS技术

2013-06-26T00:00:00+00:00

《Java Web开发实战1200例》实用案例之第三章HTML/CSS技术

1 前言

这一章主要要介绍了HTML/CSS技术，包括页面效果、表格样式、鼠标样式、文字及列表样式、文字特效和图片滤镜特效。其中页面效果中的三个案例觉得还是有点实用的，至于后面几个方面的内容，稍微归纳一下。

表格样式主要讲述了CSS边框属性border；通过两个鼠标事件（onMouseOver和onMouseOut）改变style属性来实现改变边框颜色；实用JavaScript中提供的setTimeOut()方法实现表格外边框的霓虹灯效果；通过CSS样式的progid滤镜实现背景颜色渐变；使用JavaScript的split()方法实现表格的隔行变色（stringObj.split(str)[rowIndex]）和隔列变色（stringObj.split(str)[cellIndex]）；设置表格<td>中的title属性来实现鼠标经过表格的提示信息。

鼠标样式主要介绍了cursor属性来实现不同的鼠标形状以及在CSS样式中设置cursor的url属性实现动画光标（动态光标是一个.ani文件）。

文字及列表样式介绍了CSS中的text-decoration属性；在页面中使用<rt>和<ruby>标签实现在文字上方标注说明标记；使用段落标签<p>中的first-line和first-letter属性；使用CSS中<ul>的list-style-image属性实现指定图标列表。

文字特效和图片滤镜特效主要介绍了CSS样式中的glow滤镜、dropshadow滤镜、shadow滤镜、light滤镜等的用法。

2 网页换肤

在实现网页换肤时，如果需要在换肤后保持网页的风格，即使关闭浏览器也不会消失，这就需要将每次执行所调用的CSS样式文件的路径信息保存到客户端的Cookie中。实现换肤的几个步骤

1）编写不同风格的CSS样式文件；

2）在需要的页面中引用其中一个CSS样式文件作为网页默认的样式；

<link id="myCss" href="orange.css" rel="stylesheet">

3）在<script>标签中编写保存cookie信息的方法，用于将CSS样式文件的路径信息保存到客户端Cookie文件中；

function writeCookie(csspath) {
	var today = new Date();
	var expires = new Date();
	expires.setTime(today.getTime() + 1000*60*60*24*30);	//有效期为30天
	var str = "cssPath=" + csspath + ";expires=" + expires.toGMTString() + ";"；
	document.cookie=str;
}

4）编写读取cookie信息的方法；

function readCookie(cookieName) {
	var search = cookieName + "=";
	if(document.cookie.length > 0) {
		offset = document.cookie.indexOf(search);
		if(offset != -1) {
			offset += search.length;
			end = document.cookie.indexOf(";", offset);
			if(end != -1) {
				end = document.cookie.length;
				return unescape(document.cookie.substring(offset, end));
			}
		}
	}
}

5）编写超链接的onClick事件调用的方法；

function change(type) {
	if(type == "orange") {
		document.getElementById("myCss").href="orange.css";
		writeCookie("orange.css")
	}
	if(type == "gray") {
		document.getElementById("myCss").href="gray.css";
		writeCookie("gray.css")
	}
}

6）在页面中超链接代码。

<a href="#" onClick="change('orange')">橘色经典</a>
<a href="#" onClick="change('gray')">灰色畅想</a>

3 滚动文字

实现滚动文字的特效，主要在页面中应用<marquee>标签。通过该标签的属性可以实现不同的滚动效果，其中最常用的属性是direction(滚动的方向)、behavior(滚动的方式)、scrollamount(滚动的速度)。

比如下面的代码：

<marquee direction="left">
	滚动中......
</marquee>

效果如下：滚动中......

4 CSS控制绝对定位

在CSS中提供了灵活的定位方法，常用的定位属性包括position、left、top、width、height等，其中position属性就是实现绝对定位的关键属性，它采用了3中定位方式，包括绝对定位（absolute）、相对定位（relative）和静态定位（static）。CSS代码如下：

#top_Div {
	position: absolute;		/*绝对定位*/
	left: 20px;				/*距离左侧页面20px*/
	top: 10px;				/*距离顶部页面10px*/
}
#bottom_Div {
	position: absolute;		/*绝对定位*/
	left: 130px;			/*距离左侧页面130px*/
	top: 10px;				/*距离顶部页面10px*/
}

《Java Web开发实战1200例》实用案例之第二章Java语言基础

2013-06-25T00:00:00+00:00

《Java Web开发实战1200例》实用案例之第二章Java语言基础

1 使用位运算进行加密

通过位运算的异或运算符^把字符串与一个指定的值进行异或运算，从而改变字符串每个字符的值，这样就可以得到一个加密后的字符串。当把加密后的字符串作为程序输入内容，异或运算会把加密后的字符串还原为原有字符串的值。程序如下：

package info.luyueming.java;

import java.util.Scanner;

public class Example {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入一个英文字符串或者解密字符串");
		String password = scan.nextLine();		//获取输入
		char[] array = password.toCharArray();	//获取字符数组
		for(int i=0; i<array.length; i++) {		//遍历字符数组
			array[i] = (char) (array[i]^20000);	//对每个数组元素进行异或运算
		}
		System.out.println("加密或解密结果如下：");
		System.err.println(new String(array));	//输出密钥
	}
}

运行结果如下：

请输入一个英文字符串或者解密字符串
http://luyueming.info
加密或解密结果如下：
么乔乔乐业丏丏乌乕乙乕久乍义乎乇与义乎乆乏

请输入一个英文字符串或者解密字符串
么乔乔乐业丏丏乌乕乙乕久乍义乎乇与义乎乆乏
加密或解密结果如下：
http://luyueming.info

2 精确使用浮点数——BigDecimal类

在货币运算中，经常会涉及小数运算。在计算机中所有数字都是使用二进制进行存储的，而二进制无法精确地表示所有的小数，所以使用基本数据类型进行小数运算会有一些误差，本实例将通过BigDecimal类实现精确的小数运算。

BigDecimal类是在java.math.*类包中，在使用时需要引入该类包，该类主要有使用加、减、乘、除四种运算方法

public BigDecimal add(BigDecimal value);                        //加法
public BigDecimal subtract(BigDecimal value);                   //减法 
public BigDecimal multiply(BigDecimal value);                   //乘法
public BigDecimal divide(BigDecimal value);                     //除法

下面看一下实例：

package info.luyueming.java;

import java.math.BigDecimal;

public class AccurateFloat {
	public static void main(String[] args) {
		//一般算法
		double money = 2;
		double price = 1.1;
		double result = money - price;
		System.out.println("非精确计算");
		System.out.println("剩余金额：" + result);	//输出运算结果
		//精确浮点数的解决办法
		BigDecimal money1 = new BigDecimal("2");
		BigDecimal price1 = new BigDecimal("1.1");	
		BigDecimal result1 = money1.subtract(price1);	
		System.out.println("非精确计算");
		System.out.println("剩余金额：" + result1);	//输出精确结果
	}
}

输出结果：

非精确计算
剩余金额：0.8999999999999999
非精确计算
剩余金额：0.9

3 不使用第三个变量实现两个变量的互换

变量互换常见于数组排序算法中，当判断两个数组元素需要交互时，将创建一个临时变量来共同完成互换，临时变量的创建增加了系统资源的消耗。如果需要交换的是两个整数类型的变量，那么可以使用更高效的方法。如下所示：

package info.luyueming.java;

import java.util.Scanner;

public class VariableExchange {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入变量A的值");
		long A = scan.nextLong();
		System.out.println("请输入变量B的值");
		long B = scan.nextLong();
		System.out.println("A=" + A + "\tB=" + B);
		System.out.println("执行变量互换...");
		A = A ^ B;
		B = B ^ A;
		A = A ^ B;
		System.out.println("A=" + A + "\tB=" + B);
	}
}

输出结果：

请输入变量A的值
20
请输入变量B的值
30
A=20    B=30
执行变量互换...
A=30    B=20

异或^和其他位运算符并不会改变变量本身的值，即A^B;没有任何意义。这里变量的互换主要应用了异或的公式：

a ^ b ^ a = b

4 使用for循环输出杨辉三角

杨辉三角由数字排列，可以把它看作一个数字表，其基本特性是两侧数值均为1，其他位置的数值是其正上方的数值与左上角数值之和。由于Java语言中的二维数组其实是一维数组的每个元素都是另一个一维数组，所以第二维数组的长度可以任意。这比其他语言的数组更灵活，而且多维数组也是如此。在本例中，创建一个二维数组，并指定二维数组的第一维长度，这个数组用于存放杨辉三角的数值表，再通过双层for循环来实现第二维数组的长度，然后计算整个数组的每个元素值。

package info.luyueming.java;

public class YanghuiTriangle {

	public static void main(String[] args) {
		int triangle[][] = new int[8][];
		//遍历二维数组的第一层
		for(int i=0; i<triangle.length; i++) {
			triangle[i] = new int[i+1];
			//遍历第二层数组
			for(int j=0; j<triangle[i].length; j++) {
				//将两侧的数组元素赋值为1
				if(i == 0 || j == 0 || j == triangle[i].length - 1 ) {
					triangle[i][j] = 1;
				} else {
				//其他数值通过公式计算
					triangle[i][j] = triangle[i-1][j] + triangle[i-1][j-1];
				}
				//输出数组元素
				System.out.print(triangle[i][j] + "\t");
			}
			System.out.println();
		}
	}

}

输出结果如下：

1
1    1
1    2    1
1    3    3    1
1    4    6    4    1
1    5    10   10   5    1
1    6    15   20   15   6    1
1    7    21   35   35   21   7    1

5 使用嵌套循环输出九九乘法表

Java基本语法中的for循环非常灵活并且可以嵌套使用，其中双层for循环是程序开发中使用最频繁的，常用于操作表格数据。对于行数与列数相同的表格操作比较简单，但是类似九九乘法表就不好控制了，因为它的列数要与行数对应，可以说这个表格是个三角形（在面试与等级考试中常出现这类题目）。本程序主要通过创建双层for循环来实现，第一层（外层循环）用于控制表格的行；第二层（内层循环）用于控制表格的列。程序如下：

package info.luyueming.java;

public class MultiplicationTable {

	public static void main(String[] args) {
		//循环变量从1到9
		for(int i=1; i<=9; i++) {
		//第二层循环控制变量与第一层最大索引相等
			for(int j=1; j<=i; j++) {
				//输出结果但不换行
				System.out.print(j + "×" + i + "=" + i*j + "\t");
			}
			System.out.println();
		}
	}

}

运行结果如下：

1×1=1
1×2=2   2×2=4
1×3=3   2×3=6   3×3=9
1×4=4   2×4=8   3×4=12  4×4=16
1×5=5   2×5=10  3×5=15  4×5=20  5×5=25
1×6=6   2×6=12  3×6=18  4×6=24  5×6=30  6×6=36
1×7=7   2×7=14  3×7=21  4×7=28  5×7=35  6×7=42  7×7=49
1×8=8   2×8=16  3×8=24  4×8=32  5×8=40  6×8=48  7×8=56  8×8=64
1×9=9   2×9=18  3×9=27  4×9=36  5×9=45  6×9=54  7×9=63  8×9=72  9×9=81

6 for循环输出空心的菱形

本实例在输出菱形的基础上加大难度，输出空心的菱形图案，程序如下：

package info.luyueming.java;

public class Diamond {

	public static void main(String[] args) {
		printHollowRhombus(10);
	}

	public static void printHollowRhombus(int size) {
		if(size % 2 == 0) {
			size ++;	//计算菱形的大小
		}
		
		for(int i=0; i<size/2+1; i++) {
			for(int j=size/2+1; j>i+1; j--) {
				System.out.print(" ");		//输出左上角的空白
			}
			for(int j=0; j<2*i+1; j++) {
				if(j == 0 || j == 2*i) {
					System.out.print("*");	//输出菱形上半部边缘
				} else {
					System.out.print(" ");	//输出菱形上半部空心
				}
			}
			System.out.println();
		}
		
		for(int i=size/2+1; i<size; i++) {
			for(int j=0; j<i-size/2; j++) {
				System.out.print(" ");		//输出左下角的空白
			}
			for(int j=0; j<2*size-1-2*i; j++) {
				if(j == 0 || j == 2*(size-i-1)) {
					System.out.print("*");	//输出菱形下半部边缘
				} else {
					System.out.print(" ");	//输出菱形下半部空心
				}
			}
			System.out.println();
		}
	}
	
}

输出结果如下：

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

购买域名后如何绑定在Github上托管的网站

2013-06-21T00:00:00+00:00

购买域名后如何绑定在Github上托管的网站

1 前言

在介绍之前，首先得搞清楚Github托管项目所支持的类型，一种是User/Organization Pages，另一种是Project Pages，这是两种Github托管网站上支持的两种基本类型。

User/Organization Pages

这个是Github为每个账户分配的一个二级域名，不过需要注意的是必须以那你的用户名作为开头,不然无法访问。例如我的用户名为lym406365619。如果我想使用Github给我分配的二级域名，必须创建名字为lym406365619.github.io的仓库。

Project Pages

除了上述提到以自己的名字来命名的仓库，其他所建的都可以看成是Project Pages。不过要想实现对页面的访问，则就需要创建gh-pages分支来访问。

2 在版本库根目录创建名为CNAME文件

在版本版本库根目录下创建名为CNAME文件，并且将你的域名或者二级域名写在文件中。例如我的购买的域名为http://luyueming.info，想通过这个域名能直接访问到http://lym406365619.github.io中的内容，则我需要在这个版本库的根目录下创建名为CNAME的文件（注意大小写）里面的内容为购买域名的网址：

luyueming.info

如果你使用的是User/Organization Pages版本库，需要在master分支根目录下创建该文件；如果使用Project Pages版本库，则需要在gh-pages分支根目录下创建该文件。

创建好之后，需要等待10分钟左右Github才会生效，可以在这段时间进行下一步操作。

3 设置DNS

进入你的域名管理，我的域名是在GoDaddy购买的，主要国外的比较便宜，而且不用备案，很方便呀。登录官网后，进入域名管理界面，里面有个DNS Manager，点击Launch，进入如下页面：

如果你想绑定在你的主域名中，你必须在A记录下添加一条记录指向IP204.232.175.78。如图所述，我在A(Host)下只有一条记录，Host为@，代表网址为luyueming.info。Points to则代表你所指向的IP，这里我们是204.232.175.78。编辑好之后点击图片右上角保存就行。

如果你想绑定在子域名中，你最好创建一条CNAME记录指向你的二级域名。在CNAME下点击Quick Add就行，Host可以写一个你喜欢的名称，比如我写成blog，则代表网址blog.luyueming.info，Points to指向你在Github上托管访问的网址。点击保存即可。

4 结语

本人自己测试了一下自己的网站，终于将自己购买的域名绑定好了。之前也看了挺多资料，就是不知道怎么弄，后来发现原来不是很难。于是写下来作为参考，如果疑问请留言！

Hibernate4中buildSessionFactory()方法过时解决方案

2013-06-18T00:00:00+00:00

Hibernate4中buildSessionFactory()方法过时解决方案

在使用Hibernate4时，我们会发现hibernate中的buildSessionFactory()方法已经过时了，官网建议使用buildSessionFactory(ServiceRegistry)这个方法代替使用。之前的使用如下所示：

//此方法已经过时
	Configuration cfg = new Configuration();
	SessionFactory sf = cfg.configure().buildSessionFactory();
	Session session = sf.openSession();

下面代码为解决过时的代码，采用了单例设计模式，并且是懒汉式单例类。与饿汉式单例类不同的是，懒汉式单例类在第一次被引用时将自己实例化。如果加载器是静态的，那么在懒汉式单例类被加载时不会将自己实例化。

//新方法
package com.tool.hibernate;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateUtils {

	private static SessionFactory factory;

	static {
		Configuration cfg = new Configuration().configure();
		ServiceRegistry sr = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry();
		factory = cfg.buildSessionFactory(sr);
	}

	public static SessionFactory getSessionFactory() {
		return factory;
	}

	public static Session getSession() {
		return factory.openSession();
	}

	public static void closeSession(Session session) {
		if (session != null) {
			if (session.isOpen()) {
				session.close();
			}
		}
	}

}

Ubuntu系统中安装、升级git以及常见的HTTPS cloning errors

2013-05-25T00:00:00+00:00

Ubuntu系统中安装、升级git以及常见的HTTPS cloning errors

对刚刚接触Github的人们来说，安装及使用git是必须学会的，不过本人在Ubuntu系统安装git的时候也出现多几个问题，现在总结记录以下，也从网上找了一些常见的问题，方便以后使用的时候参考参考，免得下次安装再出现类似问题。

1 Windows、MAC下安装git

首先简单介绍以下其他系统中如何安装git。

1）在Windows系统中，安装git相当简单，直接下载git的应用程序，像普通应用程序安装一样，下载地址点击这里，安装好之后，会有一个图形界面，使用很方便，也可以使用命令来创建项目，因为它也帮你安装了一个Git Shell。

2）在MAC系统中，由于本人还未使用过，可以参考一下这篇文章Mac OS X安装Git。不过github官网的建议是：使用本地app代替使用终端安装，下载APP链接为：https://central.github.com/mac/latest。

2 Ubuntu下安装、升级git

介绍一下个人觉得最方便，最好的方法，那就是使用添加ppa的方法来安装。

ppa的地址：https://launchpad.net/~git-core/+archive/ppa

在终端运行以下命令

    $ sudo apt-add-repository ppa:git-core/ppa
    $ sudo apt-get update
    $ sudo apt-get install git

如果本地已经安装过git，可以使用升级命令：

    $ sudo sudo apt-get dist-upgrade

3 运行git clone HTTPS出现的错误及解决办法

在使用git clone命令时，使用https链接进行clone时，可能会出现以下错误：

    error: The requested URL returned error: 401 while accessing
    https://github.com/user/repo.git/info/refs?service=git-receive-pack
    fatal: HTTP request failed

    Error: The requested URL returned error: 403 while accessing
    https://github.com/user/repo.git/info/refs
    fatal: HTTP request failed

    Error: https://github.com/user/repo.git/info/refs not found: did you run git
    update-server-info on the server?

如果出现上述错误，解决办法如下：

1）检查以下你的git版本，如果你的版本低于1.7.10，那么你就需要升级以下你的git，升级方法在上面已经介绍里，命令：

    $ git --version
    git version 1.7.10.4

2）检查以下你的远程仓库是否存在于Github上，并且URL是大小写敏感的，看看是不是字字母大小写弄错了。比如我的运行程序：

    $ git remote -v
    # View existing remotes
    origin git@github.com:lym406365619/lym406365619.github.com.git (fetch)
    origin git@github.com:lym406365619/lym406365619.github.com.git (push)

如果是在不行的话，使用SSH代替HTTPS，这个好像安装之后就可以用，不会出错。向Github添加SSH keys的教程可以参考以下我的这篇文章，点击这里。

使用Tapir为Jekyll博客实现全局搜索

2013-05-21T00:00:00+00:00

使用Tapir为Jekyll博客实现全局搜索

想在Jekyll博客上添加一个静态搜索，这样方便搜索相应的关键字。虽然自己也把博客归类，并给每篇博客贴上标签，但是个人还是比较喜欢折腾，总感觉有个搜索功能是非常好的一件事情。于是上网也搜集了一下相关资料，发现Jekyll博客添加搜索功能还是稍微有点麻烦的，而且有些功能还不是很好。只能搜索英文关键字，兼容性也有点欠缺，有的也只是实现博客标题以及日期搜索。

个人大致归类了一下，在Jekyll博客搜索主要有一下几种实现：

1）利用Plugin + JavaScriot的方式；

2）利用Google提供的Google Custom Search方法，这个操作很简单，功能很好，但在国内来说不是很稳定，不太实用；

3）实用JQuery搜素静态文本的API来解决。

下面我介绍一种非常简单的站内搜素——Tapir。这也是我参考网上Dan’s的一篇文章叫《使用Tapir实现jekyll的站内搜索功能》。

从官网可以得知，Tapir是专门为静态页面，比如博客等设计出来的一种站内搜素功能。可以通过简单的RSS订阅创建索引，并返回JASON格式的搜素结果，并且对中文支持也非常棒。下面我介绍一下如何部署。

1 添加RSS feed

如果你的博客还没有创建RSS feed，请在你的根目录下创建一个名为atom.xml的文件，添加一下内容：

   ---
layout: nil
title : Atom Feed
---
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
 
  <title>{{ site.title }}</title>
  <link href="{{ site.production_url }}/{{ site.JB.atom_path }}" rel="self"/>
  <link href="{{ site.production_url }}"/>
  <updated>{{ site.time | date_to_xmlschema }}</updated>
  <id>{{ site.production_url }}</id>
  <author>
    <name>{{ site.author.name }}</name>
    <email>{{ site.author.email }}</email>
  </author>

  {% for post in site.posts %}
  <entry>
    <title>{{ post.title }}</title>
    <link href="{{ site.production_url }}{{ post.url }}"/>
    <updated>{{ post.date | date_to_xmlschema }}</updated>
    <id>{{ site.production_url }}{{ post.id }}</id>
    <content type="html">{{ post.content | xml_escape }}</content>
    <summary type="html">{{ post.description | xml_escape }}</summary>
  </entry>
  {% endfor %}

</feed>

之后在你的html页面head标签中添加下面代码：

<link href="/atom.xml" type="application/atom+xml" rel="alternate" title="Sitewide ATOM Feed">

若果你已经含有atom.xml这个文件，在格式entry里添加summary，也就是每篇博客的摘要部分。下面我介绍一下上面需要注意的几个注意事项：

1）首先得现在你的配置文件_config.yml中配置一下属性site.production_url、site.JB.atom_path、site.author.name、site.author.email，不然就无法使用这些参数属性，可能会影响后面搜索功能的使用。如果你不想设置，可以直接在上面选项中填写，比如{{ site.title }}可以写一个你自己喜欢的名称。以下是我设置的内容，可以参考一下：

title : lym的博客
author :
  name : lym
  email : luyueming1989@gmail.com
  github : https://github.com/lym406365619

production_url : http://luyueming.info

JB :
  BASE_PATH : false
  atom_path : /atom.xml

2）在使用post.description选项时，在你需要发表的md文件里添加description选项，比如我这篇博客的设置：

配置好RSS feed后，你可以在本地运行Jekyll，访问http://loaclhost:4000/atom.xml看看你本地的RSS文件是否有问题。如果出现你所有的文章以及摘要，那说明你打配置文件没有出错。接着将你的修改好的项目提交到Github上吧。

2 进入Tapir提交RSS feed

Tapir的官网为http://tapirgo.com，进入官网后，在Your RSS feed选项中填写atom.xml的访问网址，比如我的就是http://luyueming.info/atom.xml。这里需要注意的是，你可以提交带有http的网址，也可以提交不含http的网址，因为生成的token并不是一样的。不过经本人测定，还是选择带有http的那个url，不然在你部署完成之后，搜索的时候可能会出现重复的两条记录，即同一篇博文出现两次。之后在下面选项填好你的E-mail地址，点击大按钮GO！就可以帮你自动生成一个token以及一个secret token。这边我们只需要记下第一个token就行，生成页面如下所示。

3 加入search框以及JavaScript

在你需要搜索的界面加上一个search框，代码如下：

<form class="navbar-search pull-right" action="search.html">
  <input type="text" class="search-query" placeholder="Search">
</form>

由于搜索用到了JQuery，需要加入两个JS文件jquery.min.js和jquery-tapir.min.js。由于search.html是在加载时执行搜索，所以这两个JS文件必须在header中加载，我的代码如下：

<script src="/js/jquery-1.6.1.min.js">
<script src="/js/jquery-tapir.min.js">

你可以在Github上下载这两个文件，使用git clone命令

  $ git clone git@github.com:TapirGo/jquery-plugin.git

4 创建search.html

由于上面的action为search.html。在根目录下创建该文件，内容如下：

    ---
layout: default
title: 搜索结果
---
{% include JB/setup %}
<divclass="post_cont"> 
  <h1>搜索结果</h1> 

  <div id="search_results"> 
  </div>
  <script>
    $('#search_results').tapir({'token': '519992c33f61b05b19000d6f'});
  </script>

</div>

上面的红色字体就是之前生成的token，用你生成的值代替它就行了。

按照上述方法部署之后，应该就能在站内实现全局静态搜索了。

如何在Github托管网站中添加谷歌分析（Google Analytics）——异步跟踪

2013-05-19T00:00:00+00:00

如何在Github托管网站中添加谷歌分析（Google Analytics）——异步跟踪

首先了解一下什么是谷歌分析，进入中文官网请点击这里。

当拥有自己个人网站的时候，我们就可以利用它来评估广告的投资回报率，并对您的Flash、视频以及社交网络网站和应用进行跟踪等功能。这里我主要介绍如何在Github上配置Google分析。

1 创建Github二级域名

当然，如果想拥有一个个人域名的网站，又不想花钱去买域名以及服务器，你可以在Github网站上注册账号。登入之后，你就可以创建新项目。在Github中，一个项目对应唯一的Git版本库。Github为每一个用户分配了一个二级域名username.github.com。比如我的二级域名就是lym406365619.github.com，我们可以很容易的创建自己二级域名中的主页，只要在托管空间下创建一个名为username.github.com的版本库，像其master分支提交网站静态页面即可，其中网站的首页为index.html。其中向Github添加SSH公钥可以参考一下我的这篇文章(http://lym406365619.github.io/blog/2013/05/16/add-ssh-keys-into-your-github/)。

2 获得google分析的tracking_id

进入google分析官网。登陆进去，依次点击管理 –> 新账户，选择想要跟踪的内容，这边我们选着网站，跟踪方法选择Universal Analytics,接着填入网站名称、网址等基本信息，点击获取跟踪ID，此时网站会总动帮你生成一个跟踪ID以及你的跟踪代码，下图是我的账户生成的跟踪ID以及跟踪代码。

3 将Google分析部署到你的Github项目

——设置tracking_id

打开_config.yml配置文件，设置一下JB/analytics下的google的tracking-id，如下所示:

    JB :
  analytics :
    provider : google 
    google : 
    tracking_id : 'your id'

然后再向你需要运用Google分析的网站添加你刚才生成的javascript的跟踪代码。这样就能实现google分析跟踪设置。由于我想在我二级域名下的所有发表的博文都用google进行代码分析。因此参考Jekyll Bootstrap的设置，如果你本来就利用它的框架源码，就不要设置以下内容，只需改变一下上文中的跟踪ID即可。如果你设计了自己的主题框架，在需要进行google分析的页面中添加以下源码。比如我在_layout下的default.html和post.html中添加如下代码：

    {% include JB/analytics %}

注意：{% include JB/analytics %}应放在相应网页作为结束标记的</head>标记之前，且紧邻该标记。如果您的网站是使用模板来生成网页，请将代码段添加到包含<head>部分的文件中，放在作为结束标记的 </head>标记之前，且紧邻该标记。要在所有浏览器中都获得最佳效果，当在网站中加入其他脚本时，建议您采用以下两种方式之一：

1）放到HTML</head>部分的跟踪代码段之前；

2）在跟踪代码段与所有网页内容之后（如置于HTML正文的底部）。

其中analytics位于_layouts下的JB文件夹里，代码为：

     {% if site.safe and site.JB.analytics.provider and page.JB.analytics != false %}

  {% case site.JB.analytics.provider %}
  {% when "google" %}
    {% include JB/analytics-providers/google %}
  {% when "getclicky" %}
    {% include JB/analytics-providers/getclicky %}
  {% when "mixpanel" %}
    {% include JB/analytics-providers/mixpanel %}
  {% when "custom" %}
    {% include custom/analytics %}
  {% endcase %}

{% endif %}

因为之前_config.yml配置文件中设置为google，所以应该执行JB/analytics-providers/google里面的代码。下面应该是添加JavaScript代码里。

——设置JavaScript代码

刚开始我把之前生成的JavaScript代码复制到_include/JB/analytics-providers/google里面，但这个时候问题出现了，我利用谷歌调试工具进行测试，发现代码没有生效（一会我会告诉大家如何知道自己的跟踪已经设置成功了），不知道什么原因，而且我也是按照官方的设置进行部署的。于是我就使用JB使用的异步跟踪设置方式，发现测试成功。代码如下：

    <script type="text/javascript">

  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', '{{ site.JB.analytics.google.tracking_id }}']);
  _gaq.push(['_trackPageview']);

  (function() {
    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
  })();

</script>

其中上述蓝色斜粗体可以代替成你获得的tracking_id。如果你不代替，必须在配置文件_config.yml中配置相关属性，如上所述。

4 调试、检测谷歌异步跟踪

Google分析官方提供了跟踪代码问题指导，列出常见的跟踪代码错误、常见报告数据问题以及调试方法。

下表是不同浏览器所使用不同的测测试调试工具：

浏览器	调试工具
All	Firebug Lite
Chrome	Google Analytics Tracking Code Debugger
Chrome	Built-in Developer Tools (e.g. Resources)
Firefox	Live HTTP Headers
Firefox	Firebug
IE	Fiddler
Sarari	Built-in Activity window
IE/Sarari/Firefox	Charles

我使用的是Firefox,介绍一下如何在Firefox调试谷歌异步跟踪是否正常运行，我使用的是Live HTTP Headers工具

第一步：下载并安装Live HTTP Headers；安装好后重启浏览器，一般会提示你重启浏览器；

第二步：打开Live HTTP Headers插件，在菜单栏选择Tools(工具) –> LiveHTTPHeaders；

第三步：点击打开页面上的Generator选项，并选择右边选项中的images、CSS、request；

第四步：打开含有Google分析跟踪插件的页面，即你要检测的页面。如果你之前已经打开了，刷新页面就行；

第五步：在刷新进入页面后，验证页面是否对urchin.js或者ga.js发出请求；

第六步：检查是否对_utm.gif发出请求。

如果实现上述步骤里，说明你的追踪设置应该没有问题。

如果想使用其他浏览器进行检测，请看官方文档吧。

以下是我测试页面的结果:

5 结语

个人提交Google跟踪分析已经两天了，不过我的Google跟踪状态还是“未安装跟踪代码”，上网搜了以下，好像确实要等很久，如果各位也像我一样，不用着急，慢慢等吧。不过网站的一些数据还是可以看到的，因为Google会自动帮你生成一个报告分析，看了一下还是很详细的，可以慢慢研究。

Github项目添加SSH公钥

2013-05-16T00:00:00+00:00

Github项目添加SSH公钥

1 测验SSH公钥是否添加到Github账户中

在使用git clone命令时，如果你使用的操作系统未在Github网站上添加SSH公钥，比如拷贝jekyll-bootstrap项目，使用命令git clone git@github.com:plusjade/jekyll-bootstrap.git。系统会报如下错误： <pre class="command-line"> Permission denied (publickey). fatal: The remote end hung up unexpectedly </pre> 或者你可以使用ssh命令连接github.com的SSH服务，登录用户名为git（所有GitHub用户共享此SSH用户名，不要写成其他），测试如下 <pre class="command-line"> $ ssh -T git@github.com Permission denied (publickey). </pre> 上面的例子显示登录失败，这是因为我们还未在GitHub账户中添加SSH公钥。这时需要在本地创建SSH公钥，然后将生成的SSH公钥的文件内容添加到Github帐号上去。

2 生成SSH公钥

创建SSH公钥的方法很简单，执行如下命令： <pre class="command-line"> $ ssh-keygen -t rsa -C “your_email@youremail.com” </pre>

执行这条命令会提示文件保存路径，press Enter；

然后提示输入passphrase（密码），输入两次（可以不输直接两次Enter）；

然后会在.ssh目录生产两个文件：id_rsa和id_rsa.pub。

其中~/.ssh/id_rsa是私钥文件，~/.ssh/id_rsa.pub是公钥文件。注意私钥文件要严加保护，不能泄露给任何人。如果在执行ssh-keygen命令时选择了使用口令保护私钥，私钥文件是经过加密的。至于公钥文件~/.ssh/id_rsa.pub则可以放心地公开给他人。

3 添加SSH公钥

使用文本编辑工具打开公钥文件~/.ssh/id_rsa.pub，可以使用gedit、cat、vim等编辑器，这里我使用gedit打开: <pre class="command-line"> $ gedit ~/.ssh/id_rsa.pub </pre>

接着拷贝id_rsa.pub文件内的所有内容，粘贴到github帐号管理中的添加SSH界面中。登录你的Github帐号后

1）点击右上方的Accounting settings图标

2）选择 SSH keys

3）点击 Add SSH key

4）在Title里填一个你自己喜欢的名称，然后将上面拷贝的~/.ssh/id_rsa.pub文件内容粘帖到Key中

5）点击“add key”按钮

如下图所示：

添加过程github会提示你输入一次你的github密码。

4 测试SSH连接Github

使用如下代码测试，结果如下：

    lym@lym-desktop:~$ ssh -T git@github.com
    Hi lym406365619! You've successfully authenticated, but GitHub does not provide shell access

如果出现上述，则表明已经SSH设置成功了。

5 设置git用户名与邮箱

打开电脑终端，首先设置你的用户名：

    $ git config --global user.name "Your Name Here"
    # Sets the default name for git to use when you commit

之后设置你的邮箱： <pre class="command-line"> git config –global user.email “your_email@example.com” # Sets the default email for git to use when you commit </pre>

注意：你的邮箱地址必须跟你其中的一个Github账户有关。如果不是，请点击这里，在你的Github账户中添加邮箱，并且也可以通过上述链接隐藏你的邮箱。

且歌且行

2013-05-14T00:00:00+00:00

且歌且行

“蜂蝶去纷纷，香风隔岸闻”。读起来宛如身处世外桃源，此情此景，似曾相识，却又难以追忆。也许是在那个无忧无虑的年纪，尚不懂表达感情，但毕竟天真烂漫的笑过，记忆封存。如今呢，君心可晴？

心情是否阳光灿烂并不完全取决于外部环境。站在海边，心情阴霾的人看到的是哀鸣的海鸟，满目苍凉；心情明媚的人却看到的是振翅的海燕，心旷神怡。外界的风景如同一面能照出心灵的明镜。你以怎样的心去对待它，它就会还你怎样的风景。人生是条单行道，只能走一遍，请为自己而活。偶尔体会一下“无丝竹之乱耳，无案牍之劳形”的惬意，给心情放个长假，让心灵小憩一下。

把哀思，惆怅放在一边。哼一曲轻快的小调，出去走走，也许是走过千百遍的林荫小道，可是不一样的心情会让你有不一样的发现。看阳光调皮地在叶子间穿梭，投下斑驳的光影；听蝉整齐划一的鸣叫；闻潮湿的泥土散发出的淡淡清香。拥有一份好心情，让彩虹化作绕指柔，让夕阳轻抚脸庞，染红发丝。

把悲伤，辛酸放在一边。唱一首自己喜欢的歌，去远足吧！一个人漫步在白色沙滩上，任海浪拍打，弯腰捡起贝壳，海螺，让咸咸的海风吹乱头发，湿湿的空气滑过每一寸皮肤；亦或者行走在丛林间，顺着迂回的小溪踏歌前行，偶然间驻足观察一下各型各色的小昆虫，抬头仰望一下高耸入云的参天大树，感叹生命的神奇。拥有一份好心情，让叮咚的溪水为你伴奏，让快乐的鸟儿为你歌唱。

在春天播种一粒快乐，秋天你将收获一大片好心情。君心可晴！朋友，在心田埋下快乐吧！小心地呵护它，给它阳光的爱抚，雨露的滋润。这是一个简单的心灵投资，而受益人永远是你。不要做心情的奴隶，不要让任何人任何事主宰你的情绪，你才是你自己的神，唯一有权力决定你心情的人就是你自己，你可以自定义你的心情为万里无云。学会心如止水，即使没有普罗旺斯的花草香，也能微笑入梦；即使没有迪拜的纸醉金迷，也能感受幸福。

放浪形骸，踏歌暮霭；君心可晴，且歌且行。