1、没事不要用reboot,

2、reboot前最好备份数据库。（一次reboot机子，启动后mysql没有起来，发现mysql好像崩溃了，原因不详，貌似是因为机子上有两个版本的mysql）

3、不要随意用rm，rm时要保持头脑清晰。（最郁闷的是，写好好久的shell,不小心一下rm了，我都快哭了）

4、尽量用cp,不要用mv。（tomcat会自动加载war包，当时不小心把zip更改成war，项目下的图片是mv过去的，war自动解压，把图片覆盖了，即删除了，郁闷，重先抓图片）

5、开放端口要少。mysql仅请允许本机访问。

常用命令：

一、jdk安装

mv jdk-6u24-linux-i586.bin /usr/java1.6/jdk-6u24-linux-i586.bin
  cd /usr/java1.6/
  chmod 755 jdk-6u24-linux-i586.bin
  ./jdk-6u24-linux-i586.bin
 不用设置环境变量，直接将tomcat的jdk指定到jdk目录
 vi setclasspath.sh
 在开始增加：
 export JRE_HOME="/usr/java1.6/jdk1.6.0_24/"
    export JAVA_HOME="/usr/java1.6/jdk1.6.0_24/"
 启动tomcat,可以正常访问。
 启动命令，到tocmat目录下的bin
 执行：
 ./startup.sh start
 停止命令
 ./shutdown.sh
 通过以下命令可以查看进程以及端口号。
    netstat -lpn

二、权限管理

chmod
改变一个文件的权限：chmod [mode] file.txt
改变一个目录的权限：chmod [mode] dir
改变一个目录和其子目录的权限：    chmod [mode] dir -R
mode = 777 or 752 and so on.
mode的三个数字，分别表示owner,group,others所具备的权限。
1＝x 执行
2＝w 写
4＝r 读
比如owner具有所有权限，1+2+4=7,又比如 group 具有读和执行权限1+4=5。
========================================================
chown
更改文件或目录的拥有者
-R参数表示递归改变
[root@linux ~]#chown [-R] 账户名称 文件或目录
[root@linux ~]#chown [-R] 账户名称:用户组名称 文件或目录

这个命令最好不要用得太猛了，一次把var全改成了一个非root 用户，结果导致，ssh,mysql启动不起来
mysql更改： chown -R mysql:mysql   /mysqldatadir
sshd更改为root可以恢复


三、建立一个用户和root权限相同

#useradd -o -u 0 -g 0 -M -d /root -s /bin/bash admin

#passwd admin

四、apache中整合tomcat时httpd.conf末尾添加，注，必须开启proxy(module)

<IfModule mod_proxy.c>
ProxyRequests On
<VirtualHost 127.0.0.1:80>
    ServerName 127.0.0.1
 ServerAlias test.com  *.test.com
    ProxyPass        / http://localhost:8090/
    ProxyPassReverse /  http://localhost:8090/
   ProxyPreserveHost On
   ProxyVia On
</VirtualHost>

四、mysql操作

mysql -u root
SET PASSWORD FOR 'root'@'localhost' = PASSWORD('newpasswd');
即把mysql的root密码设置为newpasswd

导入数据，新建用户balidatabase，密码为：bali2010

grant all on mydatabase.*  to  username identified by 'passwd';
#生效用户权限更改
flush privileges;

乱码解决：

my.cnf大致更改如下：

[mysqld]
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
user=mysql
# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0

#使用utf-8
character-set-server=utf8

[client]

#使用utf-8
default-character-set=utf8

[mysqld_safe]
log-error=/var/log/mysqld.log
pid-file=/var/run/mysqld/mysqld.pid

tomcat的server.xml更改如下：
 <Connector port="8090" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" acceptCount="100"
                useBodyEncodingForURI="true"              
    URIEncoding="utf-8"
    disableUploadTimeout="true" />
    <!-- A "Connector" using the shared thread pool-->
 
 
在host节点下配置虚拟目录：
<Context path="" docBase="appName" />

五、日期设定：

#设置时间
 date -s 16:54:00
 date
#将时间写入cmos，保证下次启动时时间正常
 clock -w
 whereis clock
/sbin/clock -w


写得比较简陋，自己能看懂。

1.NetworkManager，NetworkMangerDispatcher:

说明：是一个自动切换网络连接的后台进程。很多笔记本用户都需要启用该功能，它让你能够在无线网络和有线网络之间切换。大多数台式机用户应该关闭该服务。一些 DHCP 用户可能需要开启它。

预设端口：无

是否需要启动：一般不需要启动。

2.acpid: 配置文件：/proc/acpi/event

说明：Advanced Configuration and Power Interface，为替代传统的APM电源管理标准而推出的新型电源管理标准。

预设端口：无

是否需要启动：如果你需要对电源进行管理，那就需要启动。

3.anacron: 配置文件：/etc/anacron

预设端口：无

说明：一个自动化运行任务。Red Hat Linux 随带四个自动化任务的工具：cron、 anacron、at、和 batc。当你的Linux主机并不是全天候开机，这个anacron就可以帮你执行在"crontab"设定的时间内没有执行的工作。举例来说，当你的主机在晚上12:00会自动关闭，但是偏偏crontab这个例行性工作是在4:00工作，这个时候例行性工作就不能起作用了。不过利用anacron就能做到。

是否需要启动：如果主机已经24小时开机，而且运行了cron，那么这个守护程序就不需要启动了。

4.apmd: 配置文件：/etc/sysconfig/apmd

预设端口：无

说明：Advanced Power Management，高级电源管理。传统的电源管理标准。一般系统都会同时支持APM和APMD两种标志，但系统加载时只需加载一个即可。对于笔记本电脑比较有用，可以了解系统的"电池电量"。

是否需要启动：如果我们使用的是台式电脑或一直开机的机型，就不需要使用这个守护程序。

5.atd: 配置文件：/etc/at.allow，/etc/at.deny

预设端口：无

说明：一个自动化运行任务。

是否需要启动：通常需要启动。不过如果你一直使用cron，那么也可以不启动。

6.auditd:

说明：auditd（Digital Audit Daemon）数码音频后台服务

是否需要启动：不需要启动。

7.autofs: 配置文件：/etc/rc.d/init.d/autofs

预设端口：无

说明：实现光盘、软盘的自动加载。

是否需要启动：一般不需要启动。

8.avahi-daemon,avahi-dnsconfd:

说明：Avahi 是 zeroconf 协议的实现。它可以在没有 DNS 服务的局域网里发现基于 zeroconf 协议的设备和服务。它跟 mDNS 一样。除非你有兼容的设备或使用 zeroconf 协议的服务，否则应该关闭它。

是否需要启动：不需要启动。

9.bluetooth: 配置文件：/etc/bluetooth/*

说明：蓝牙（Bluetooth）是给无线便携设备使用的（非 wifi, 802.11）。Bluetooth 是用于替换电缆的短程无线技术，支持 723 kbps（不对称）和 432 kbps（对称）的速度，可以传输数据和语音。Bluetooth 设备的传输范围大约 10 米（30 英尺）。

是否需要启动：不需要启动。

10.cpuspeed:

说明：监测系统空闲百分比，降低或加快CPU时钟速度和电压从而在系统空闲时把能源消耗降为最小，而在系统繁忙时最大化加快系统执行速度。

是否需要启动：需要启动。

11.crond: 配置文件：/etc/crontab

预设端口：无

说明：用来执行例行性命令的守护程序。

是否需要启动：必须启动。

12.cups: 配置文件：

CUPS服务器配置文件：/etc/cups/cupsd.conf

CUPS客户端配置文件：/etc/cups/client.conf

CUPS打印机配置文件：/etc/cups/printers.conf

CUPS中类（class）配置文件：/etc/cups/classes.conf

说明：Common UNIX Printing System，公共UNIX打印支持，为Linux提供打印功能。

是否需要启动：如果不安装打印机，就不需要启动。

13.dc_client:

说明：使用SSL安全套接字的客户端守护进程。

是否需要启动：不需要启动。

14.dc_server:

说明：使用SSL安全套接字的代理服务器守护进程。

是否需要启动：不需要启动。

15.dhcdbd:

预设端口：无

说明：这是一个让 DBUS 系统控制 DHCP 的接口。可以保留默认的关闭状态。

是否需要启动：不需要启动。

16.dund:

说明：dund 支持通过蓝牙拨号连接网络。

是否需要启动：不需要启动。

17.firstboot:

说明：它执行在安装之后的第一次启动时仅仅需要执行一次的特定任务。它可以被关闭。

是否需要启动：不需要启动。

18.gpm: 配置文件：/etc/sysconfig/mouse

预设端口：无

说明：General Purpose Mouse Daemon ，gpm为文本模式下的Linux程序如mc(Midnight Commander)提供了鼠标的支持。它也支持控制台下鼠标的拷贝，粘贴操作以及弹出式菜单。

是否需要启动：没必要的话，建议不要启动。

19.haldaemon:

说明：硬件监控系统，此服务监控硬件改变,为你改变新的或更改过的硬件。

是否需要启动：不需要启动。

20.hidd:

说明：蓝牙H.I.D服务器，对输入设备（键盘，鼠标）提供支持。

是否需要启动：不需要启动。

21.httpd: 配置文件：/etc/httpd/httpd.conf,/etc/sysconfig/httpd

预设端口：80，443

说明：提供www服务。

是否需要启动：安装www服务就启动它。

22.ibmasm:

说明：ibmasm 套件用來與 IBM Advance System Management PCI Adapter（亦稱 RSA I）進行通訊。

是否需要启动：不需要启动。

23.ip6tables:

说明：支持使用 Netfilter 6 子系统和 ip6tables 命令的 IPv6 防火墙规则，其语法在各方面都和 iptables 相同，只不过 ip6tables 支持128位的地址。

是否需要启动：目前不需要启动。

24.iptables: 配置文件：/etc/sysconfig/iptables

预设端口：无

说明：是Linux上有名的防火墙，如果连上Internet，一定要开启这个。

是否需要启动：连上Internet的主机务必启动。

25.irda:

说明：红外线设备界面，以前的无线设备支持。

是否需要启动：不需要启动。

26.irqbalance:

说明：是在多个处理器系统上分配中断号的服务。单处理器可以关闭。

是否需要启动：多处理器可以启动它。

27.kudzu: 配置文件：

/etc/sysconfig/hwconf

/etc/sysconfig/kudzu

说明：硬件自动检测程序，会自动检测硬件是否发生变动，并相应进行硬件的添加、删除工作。当系统启动时，kudzu会对当前的硬件进行检测，并且和存储在 /etc/sysconfig/hwconf中的硬件信息进行一一对照，如果某个硬件从系统中被添加或者删除时，那么kudzu就会察觉到，并且通知用户是否进行相关配置，然后修改/etc/sysconfig/hwconf，使硬件资料与系统保持同步。如果/etc/sysconfig/hwconf这个文件不存在，那么kudzu把会从/etc/modprobe.conf，/etc/sysconfig/network-scripts/和 /etc/X11/XF86Config中探测已经存在的硬件。

是否需要启动：如果启动kudzu，则每次启动系统，都会检查新硬件（checking new hardware），会延长系统启动的时间。如果你不打算增加新硬件，那么就可以关闭这个启动服务，以加快系统启动时间。

28.mcstrans:

说明：主要用于SELinux，如果你不用SELinux，可以关了。

是否需要启动：一般不需要。

29.mdmonitor:

说明：与RAID设备相关的守护程序。该服务用来监测 Software RAID 或 LVM 的信息。它不是一个关键性的服务，可以关闭它。

是否需要启动：不用Software RAID就不需要启动。

30.mdmpd:

说明：该服务用来监测 Multi-Path 设备（该类型的存储设备能被一种以上的控制器或方法访问）。

是否需要启动：不需要启动。

31.messagebus:

说明：事件监控服务，此服务在必要时向所有用户发送广播信息,如服务器将要重启。这是 Linux 的 IPC（Interprocess Communication，进程间通讯）服务。确切地说，它与 DBUS 交互，是重要的系统服务。

是否需要启动：必须启动。

32. microcode_ctl:

说明：可以编码以及发送新的微代码到kernel以更新Intel IA32系列处理器（Pentium Pro，PII，PIII，Pentium 4，Celeron, Xeon 等等 – 全部 P6 以及更高,不包括 pentium classics）。

是否需要启动：不需要启动。

33. netfs:配置文件：/etc/fstab

预设端口：无

说明：这个服务在自动的挂载/etc/fstab里记录的关于网络文件系统，如NFS，SMB等等，如果你的主机本身并没有

安装和卸载NFS、SAMBA和NCP网络文件系统

是否需要启动：不需要启动。

34. netplugd: 配置文件：

/etc/netplug/netplugd.conf

/etc/netplug.d/netplug

说明：network cable hotplug management daemon，netplugd是一个守护程序，可以监控一个或多个网络接口的状态，当某些事件触发时运行一个外部脚本程序。

是否需要启动：一般不需要启动。

35. network: 配置文件：

/etc/sysconfig/network

/etc/sysconfig/network-scripts/*

预设端口：无

说明：是用来管理网络的，所以当然要启动，不论你有没有网卡，这个服务也要启动，因为至少network会驱动lo这个网络介面。

是否需要启动：必须启动。

36. nfs:配置文件：/etc/sysconfig/nfs

预设端口：随机使用port，与protmap服务有关。

说明：NFS为Network File System的缩写，是一个流行的通过TCP/IP网络共享文件的协议。

是否需要启动：一般不需要启动。

37.nfslock

说明：NFS是一个流行的通过TCP/IP网络共享文件的协议，此服务提供了NFS文件锁定功能。

是否需要启动：不需要启动。

38.nscd

说明：密码与群查找服务，此服务用于减慢N.I.S/Y.P.nist，ldap和hesiod之类的服务，专门为这些服务提供更长的中断时间。

是否需要启动：不需要启动。

39. ntpd: 配置文件：

/etc/ntp.conf

/etc/sysconfig/ntpd

预设端口：使用port：123

说明：Network time Protocol daemon，网络时间校正协议。简单的说,NTP是用来使系统和一个精确的时间源保持时间同步的协议。

是否需要启动：一般不需要启动。

40. oddjobd:

说明：oddjobd为无特权的应用程序提供一组有特权的操作来完成它们的动作。

是否需要启动：不需要启动。

41. pand:

说明：跟蓝牙有关，pand允许你通过蓝牙连接以太网。

是否需要启动：不需要启动。

42. pcscd:

说明：该服务提供智能卡（和嵌入在信用卡，识别卡里的小芯片一样大小）和智能卡读卡器支持。

是否需要启动：如果没有读卡设备，那就快关闭它。

43. portmap:

预设端口：使用port：111

说明：Portmap守护程序为RPC服务，如NIS和NFS提供动态端口的分配。

是否需要启动：如果你启用类似NFS的服务，否则不需要启动。

44. psacct:

说明：包括几个工具用来监控进程活动的工具，包括ac,lastcomm, accton 和sa。

是否需要启动：不需要启动。

45. rdisc:

说明：这是一个端口监控程序，用来发现本地子网的路由。

是否需要启动：不需要启动。

46. readahead_early，readahead_later: 配置文件：

/etc/readahead.early.files

/etc/readahead.files

说明：readahead和readahead_early是最新推出的两个后台运行的守护程序。其作用是在启动系统期间，把启动系统所要用到的文件首先读取到内存中，然后在内存中进行执行，以加快系统的启动速度。而上面两个配置文件就保存着把要读取到内存的文件列表。

47. restorecond:

说明：用于给 SELinux 监测和重新加载正确的文件上下文（file contexts）。

是否需要启动：如果使用SELinux就开启它。

48.rpcgssd:

说明：用于NFSv4版本。

是否需要启动：不需要启动。

49.rpcidmapd:

说明：用于NFSv4版本。

是否需要启动：不需要启动。

50.rpcsvcgssd:

说明：gestion NFS v4，是Linux 2.6内核新添的功能。

是否需要启动：不需要启动。

51.saslauthd:

说明：使用SASL的认证守护程序。

52.sendmail:

说明：邮件服务器，在局域网内传递或支持一个共享的 IMAP 或 POP3 服务。

是否需要启动：不需要启动。

53.smartd:

说明：Self Monitor Analysis and Reporting Technology System服务用于监测并预测磁盘失败或磁盘问题（前提：磁盘必须支持 SMART）。

是否需要启动：如果是服务器那最好开启它。

54.smb:配置文件：/etc/samba/*

预设端口：使用port：137~139，445等。

说明：这个服务就是模拟Linux成为windows的网上邻居。

是否需要启动：不需要启动。

55.spamassassin:

说明：SpamAssassin是一款功能强大的反垃圾邮件系统。

是否需要启动：不需要启动。

56.squid:

说明：高速缓存工具，用于高速缓存网络页面及DNS登录。

是否需要启动：不需要启动。

57.sshd: 配置文件：

OpenSSH服务器配置文件：/etc/ssh/sshd_config

OpenSSH客户端配置文件：/etc/ssh/ssh_config

预设端口：22

说明：Secure Shell Protocol，实现安全地远程登录管理主机。

是否需要启动：如果想实现远程管理，就需要启动。

58.syslog: 配置文件：/etc/syslog.conf

预设端口：无

说明：记录所有的系统行为。

是否需要启动：必须启动。

59.tux:

说明：TUX是一种有GPL（GNU General Public License ）许可的基于内核的Web服务器。

60.vncserver:

说明：VNC（Virtual Network Computing，虚拟网络计算），它提供了一种在本地系统上显示远程计算机整个"桌面"的轻量型协议。

是否需要启动：如果要提供远程图形界面的管理就需要启动。

61.vsftpd: 配置文件：/etc/vsftpd/vsftpd.conf

预设端口：21，20

说明：FTP服务器软件。

是否需要启动：如果要提供FTP服务就启动。

62.winbind:

说明：Samba名称服务器，Samba网络运行所必需。务将用户与群数据从windows网络映射到Linux工作站中。

是否需要启动：不需要启动。

63.wpa_supplicant:

说明：提供无线局域网的认证、协商和漫游功能。

是否需要启动：不需要启动。

64.xfs:

预设端口：TCP 7100

说明：x font server，X Window字型服务器，为本地和远程X服务器提供字型集。

是否需要启动：如果使用run-level为5的图形界面，那么就需要启动。

65. xinetd 配置文件：/etc/xinetd.conf

预设端口：不一定，要看设定值。

说明：xinetd作为inetd的后续版本，负责管理系统中不频繁使用的服务，这些服务程序在有请求时才由xinetd服务负责启动运行，一旦完成服务请求服务程序结束运行，这样可以有效地减少对系统资源的占用率。通常，xinetd管理的程序有telnet、ftp、rsh和rlogin。关闭 inetd也就关闭了这些由它管理的服务。

是否需要启动：必须启动。

66.ypbind:

说明：这个进程是NIS的客户端组件，它负责查询客户端用来查询信息的NIS服务器，ypbind进程将NIS客户端绑定到一个NIS域，它必须在所有运行NIS客户端程序的机器上运行。

67.yum-updatesd: 配置文件：/etc/yum.conf

说明：Yellow Dog UpdaterModified，是一个自动更新、安装和删除RPM软件包的管理程序，它会自动计算软件包的管理程序，并判断哪些软件应该安装，哪些软件则不必安装。

是否需要启动：以系统管理策略而决定是否启动。

escape(), encodeURI()和encodeURIComponent()是在Javascript中用于编码字符串的三个常用的方法
escape() 方法

escape方法以Unicode格式返回一个包含传入参数内容的string类型的值。 Escape方法会将传入参数中所有的空格、标点符号、重音字符以及其它任何非ASCII字符替换为%xx的编码形式，其中xx与其所表示的字符的16进制数表示形式相同。如空格字符的16进制表示形式为0x20，则此时xx应为20，即escape(‘ ’) 返回“%20”。

escape和unescape方法能够帮助你编码和解码字符串。escape方法对于ISO Latin字符集中的字符组成的参数，返回其16进制编码。相对应的，unescape方法则能将16进制编码形式的参数转化成为其ASCII码形式。

encodeURI()方法

encodeURI方法返回一个经过编码的URI。如果将encodeURI方法的编码结果传递给decodeURI方法作参数，则能得到原始的未编码的字符串。需要注意到是encodeURI方法不编码如下字符":", "/", ";", "?"。如果想要编码这些字符，请使用encodeURIComponent方法。通过将每个属于特定的字符集合的字符替换为一个、两个或者三个（为什么是“一个、两个或者三个”本人也没有搞懂，望高人赐教）使用UTF-8编码来表示这个字符的escape序列来编码一个URI。如 ~!@#$%^&*(){}[]=:/,;?+\''"\\ 将被替换为 ~!@#$%25%5E&*()%7B%7D%5B%5D=:/,;?+''%22%5C

encodeURIComponent()方法

encodeURIComponent方法返回一个编码过的URI。如果将encodeURIComponent方法的编码结果传递给encodeURIComponent方法作参数，则能得到原始的未编码的字符串。因为encodeURIComponent方法会编码所有的字符，所以如果待编码的字符串是用来表示一个路径（如/dir1/dir2/index.htm）时，就一定要小心使用了。‘/’符号会被其编码之后，将不再是一个有效的路径标识符，所以不能被web服务器正确地识别。当字符串包含一个单独的URI component(指?后面的请求参数)的时候，请使用此方法。通过将每个属于特定的字符集合的字符替换为一个、两个或者三个（为什么是“一个、两个或者三个”本人也没有搞懂，望高人赐教）使用UTF-8编码来表示这个字符的escape序列来编码一个URIComponent。

有什么区别？何时使用？
 
escape方法并不编码字符+。而我们知道，在用户提交的表单字段中，如果有空格，则会被转化为+字符，而服务器解析的时候则会认为+号代表空格。由于这个缺陷，escape方法并不能正确地处理所有的非ASCII字符，你应当尽量避免使用escape方法，取而代之，你最好选择encodeURIComponent()方法。
escape()不编码的字符：@*/+

相对于使用escape方法，使用encodeURI方法会显得更专业一些。当你需要编码一整个URI的时候，你可以使用此方法，因为URI中的合法字符都不会被编码转换。需要注意到是字符’也是URI中的合法字符，所以也不会被编码转换。
encodeURI() 不编码的字符： ~!@#$&*()=:/,;?+''

encodeURIComponent方法在编码单个URIComponent（指请求参数）应当是最常用的。需要注意到是字符’也是URI中的合法字符，所以也不会被编码转换。
encodeURIComponent()不编码的字符： ~!*()''

下面是自己写的
再看下jdk文档里的编码和解码：

public class URLEncoder
extends Object

HTML 格式编码的实用工具类。该类包含了将 String 转换为 application/x-www-form-urlencoded MIME 格式的静态方法。有关 HTML 格式编码的更多信息，请参阅 HTML 规范。

对 String 编码时，使用以下规则：

• 字母数字字符 "a" 到 "z"、"A" 到 "Z" 和 "0" 到 "9" 保持不变。
• 特殊字符 "."、"-"、"*" 和 "_" 保持不变。
• 空格字符 " " 转换为一个加号 "+"。
• 所有其他字符都是不安全的，因此首先使用一些编码机制将它们转换为一个或多个字节。然后每个字节用一个包含 3 个字符的字符串 "%xy" 表示，其中 xy 为该字节的两位十六进制表示形式。推荐的编码机制是 UTF-8。但是，出于兼容性考虑，如果未指定一种编码，则使用相应平台的默认编码。

例如，使用 UTF-8 编码机制，字符串 "The string ü@foo-bar" 将转换为 "The+string+%C3%BC%40foo-bar"，因为在 UTF-8 中，字符 ü 编码为两个字节，C3 （十六进制）和 BC （十六进制），字符 @ 编码为一个字节 40 （十六进制）。

public class URLDecoder
extends Object

HTML 格式解码的实用工具类。该类包含了将 String 从 application/x-www-form-urlencoded MIME 格式解码的静态方法。

该转换过程正好与 URLEncoder 类使用的过程相反。假定已编码的字符串中的所有字符为下列之一："a" 到 "z"、"A" 到 "Z"、"0" 到 "9" 和 "-"、"_"、"." 以及 "*"。允许有 "%" 字符，但是将它解释为特殊转义序列的开始。

转换中使用以下规则：

• 字母数字字符 "a" 到 "z"、"A" 到 "Z" 和 "0" 到 "9" 保持不变。
• 特殊字符 "."、"-"、"*" 和 "_" 保持不变。
• 加号 "+" 转换为空格字符 " "。
• 将把 "%xy" 格式序列视为一个字节，其中 xy 为 8 位的两位十六进制表示形式。然后，所有连续包含一个或多个这些字节序列的子字符串，将被其编码可生成这些连续字节的字符所代替。可以指定对这些字符进行解码的编码机制，或者如果未指定的话，则使用平台的默认编码机制。

该解码器处理非法字符串有两种可能的方法。一种方法是不管该非法字符，另一种方法是抛出 IllegalArgumentException 异常。解码器具体采用哪种方法取决于实现。

现在的问题是：服务器返回字符到页面，页面又调用js，这个时候肯定要转义下，这是相对比较简单的需求。
服务器只需借助于apache commons包里的StringEscapeUtils类，在struts2里其实已经集成在xwrok包。
StringEscapeUtils.escapeJavaScript(returnString);
这样就可以搞定这个问题。
另外也可以用js去处理这个问题，不过没有实践，主要是自己js水平有点差，
escapeJavaScript对应的源码如下：

private static void escapeJavaStyleString(Writer out, String str, boolean escapeSingleQuote,
            boolean escapeForwardSlash) throws IOException {
        if (out == null) {
            throw new IllegalArgumentException("The Writer must not be null");
        }
        if (str == null) {
            return;
        }
        int sz;
        sz = str.length();
        for (int i = 0; i < sz; i++) {
            char ch = str.charAt(i);

            // handle unicode
            if (ch > 0xfff) {
                out.write("\\u" + hex(ch));
            } else if (ch > 0xff) {
                out.write("\\u0" + hex(ch));
            } else if (ch > 0x7f) {
                out.write("\\u00" + hex(ch));
            } else if (ch < 32) {
                switch (ch) {
                    case '\b' :
                        out.write('\\');
                        out.write('b');
                        break;
                    case '\n' :
                        out.write('\\');
                        out.write('n');
                        break;
                    case '\t' :
                        out.write('\\');
                        out.write('t');
                        break;
                    case '\f' :
                        out.write('\\');
                        out.write('f');
                        break;
                    case '\r' :
                        out.write('\\');
                        out.write('r');
                        break;
                    default :
                        if (ch > 0xf) {
                            out.write("\\u00" + hex(ch));
                        } else {
                            out.write("\\u000" + hex(ch));
                        }
                        break;
                }
            } else {
                switch (ch) {
                    case '\'' :
                        if (escapeSingleQuote) {
                            out.write('\\');
                        }
                        out.write('\'');
                        break;
                    case '"' :
                        out.write('\\');
                        out.write('"');
                        break;
                    case '\\' :
                        out.write('\\');
                        out.write('\\');
                        break;
                    case '/' :
                        if (escapeForwardSlash) {
                            out.write('\\');
                        }
                        out.write('/');
                        break;
                    default :
                        out.write(ch);
                        break;
                }
            }
        }
    }

可以用js去实现也是一样的，网上也有类似的js代码。

出现的问题描述：服务器返了string，经过escapeJavaScript处理后到js代码，js代码又要用这些string去输出html.比如img的src为js处理后的字符串，
最后经过测试得出以上语句去处理这些问题：
string=encodeURIComponent(string).replace(/@/g,'%40').replace(/'/g,"'").replace(/"/g,'"');
转化@是为了获取服务器资源，比如图片地址，可以正常输出。其实输出时后面的转化单引号和双引号是为了保险起见。比如<img src='*****.jpg'/>这时就只需要转化单引号就可以了，这里主要是针对图片的处理来做的，@在其它地方有没有必要转化没有测试，如果要显示图片，得转化。

出现的问题描述：带特殊字符串的图片名要正常显示出来，得转化下：比如要显示文件名为：~！@#￥%……&*（）——+.jpg的图片，代码如下：
java.net.URLEncoder.encode(photoName,"utf-8")).replace("+", "%20"),转化时因为URLEncoder把空格转化成了+,所以最后得把+替换回去，20是十六进制的，相当于十进制的32，即对应为空格。
经过转化后，图片带特殊字符就能正常显示。

actionName

Purpose

Returns the name of the currently executing action.

controllerName

Purpose

Returns the name of the currently executing controller.

defaultAction

Purpose

Allows you to explicitly specify the default action that should be executed if no action is specified in the URI.

Examples

class BookController {
static defaultAction = "list"
def list = {
[books:Book.list()]
}
}

grailsApplication

Purpose

An instance of the org.codehaus.groovy.grails.commons.GrailsApplication class.

Examples

class BookController {
def list = {
def bookClass = grailsApplication.classLoader.loadClass("Book")
[book:bookClass.newInstance()]
}
}

Description

The GrailsApplication class provides information about the conventions within Grails and access to metadata, config and the ClassLoader

servletContext

Purpose

The servletContext object is an instance of the Servlet API's ServletContext class.

Examples

class BookController {
def doSomething = {
def input
try {
input = servletContext.getResourceAsStream("/WEB-INF/myscript.groovy")
def result = new GroovyShell().evaluate(input.text)
render result
}
finally {
input.close()
}
	}
}

Description

The Servlet API's ServletContext is useful for, amongst other things, storing global application attributes, reading local server resources and establishing information about the servlet container.

withForm //防止重复提交表单

Purpose

Used to handle duplicate form submissions.

Examples

withForm {
// good request
}.invalidToken {
// bad request
}

Description

The withForm method requires the use of the useToken attribute in a form

<g:form useToken="true" ...>

Then in your controller code you can use the withForm method to handle valid and invalid requests:

withForm {
// good request
}.invalidToken {
// bad request
}

withFormat

Purpose

Used to execute different responses based on the incoming request Accept header, format parameter or URI extension. See content negotiation for more information.

Examples

import grails.converters.*
class BookController {
def books
def list = {
this.books = Book.list()
withFormat {
html bookList:books
js { render "alert('hello')" }
xml { render books as XML }
}
}
}

Description

The withFormat method takes a block within the scope of which you can execute different methods whose names match the content type you want to respond to. For example:

withFormat {
html bookList:books
js { render "alert('hello')" }
xml { render books as XML }
}

Here we invoke three methods called html, js and xml that use mime type names configured in grails-app/conf/Config.groovy (See content negotiation for more information). The call to html accepts a model (a map) which is passed on to the view. Grails will first search for a view called grails-app/views/book/list.html.gsp and if that is not found fallback to grails-app/views/book/list.gsp.

Note that the order of the types is significant if either the request format is "all" or more than one content type has the same "q" rating in the accept header. In the former case, the first type handler in the block is executed ("html" in the short example above). The latter case is more confusing because it only holds if there is more than one content type with the highest "q" rating for which you have a type handler and you have more than one type handler matching that "q" rating. For example, say the request has "text/html" and "application/xml" with a "q" rating of 1.0, then this code:

withFormat {
xml { … }
html { … }
}

An inexpensive check to see if the key exists in the cache.

 

Parameters:

key - the key to check for

Returns:

true if an Element matching the key is found in the cache. No assertions are made about the state of the Element.

getQuiet

Element getQuiet(java.lang.Object key)
throws java.lang.IllegalStateException,
CacheException

Gets an element from the cache, without updating Element statistics. Cache statistics are also not updated.

 

Parameters:

key - a serializable value

Returns:

the element, or null, if it does not exist.

Throws:

java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

CacheException

Since:

1.2

See Also:

isExpired(net.sf.ehcache.Element)

isExpired

boolean isExpired(Element element)
throws java.lang.IllegalStateException,
java.lang.NullPointerException

Checks whether this cache element has expired.

The element is expired if:

1. the idle time is non-zero and has elapsed, unless the cache is eternal; or
2. the time to live is non-zero and has elapsed, unless the cache is eternal; or
3. the value of the element is null.

 

Parameters:

element - the element to check

Returns:

true if it has expired

Throws:

java.lang.IllegalStateException - if the cache is not Status.STATUS_ALIVE

java.lang.NullPointerException - if the element is null

Element element=cache.getQuiet(key);
        log.info("element:"+element);
        if(element!=null){
            log.info("cache.isExpired(element):"+cache.isExpired(element));
            log.info("cacheName:" + cacheName + " key:" + key + " isExist:true");
            return true;
        }
        else{
            log.info("cacheName:" + cacheName + " key:" + key + " isExist:false");
            return false;
        }

通常单例模式在Java语言中，有两种构建方式：

• 懒汉方式:指全局的单例实例在第一次被使用时构建。延迟初始化。
• 饿汉方式:指全局的单例实例在类装载时构建。 急切初始化。

1，饿汉式单例类

public class Singleton1 {
    
    private Singleton1() {
    }
    // 在自己内部定义自己一个实例.
    // 注意这是private 只供内部调用

    private static Singleton1 instance = new Singleton1();

    /** *//**
     *  这里提供了一个供外部访问本class的静态方法，可以直接访问　　
     * @return
     */
    public static Singleton1 getInstance() {
        return instance;
    }
}

2，懒汉式单例类

public class Singleton2 {

    private static Singleton2 instance = null;
    /** *//**
     * 这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　
     * 使用时生成实例，提高了效率！
     * @return
     */
    public static  Singleton2 getInstance() {    
        if (instance == null)
            instance = new Singleton2();
        return instance;
    }
}

public class Singleton3 {

    private static Singleton3 instance = null;
    /** *//**
     * 这个方法比上面有所改进，不用每次都进行生成对象，只是第一次　　　
     * 使用时生成实例，提高了效率！
     * 为了多线程不出错，加入了同步标志
     * @return
     */
    public static synchronized  Singleton3 getInstance() {    
        if (instance == null)
            instance = new Singleton3();
        return instance;
    }

}

public class Singleton4 {
   private static volatile Singleton4 instance;
    /** *//**
     * 双重加锁实现多线程运用和性能优化
     * @return
     */
    public static Singleton4 getInstance()
    {
      if (instance == null)
      {
        synchronized(Singleton4.class) {  //1
          if (instance == null)          //2
            instance = new Singleton4();  //3
        }
      }
      return instance;
    }
}

增加以下配置：

<!--ehcache web page cache -->
     <filter>
    <filter-name>fragmentCache</filter-name>
    <filter-class>net.sf.ehcache.constructs.web.filter.SimplePageFragmentCachingFilter
    </filter-class>
     <init-param>
      <param-name>suppressStackTraces</param-name>
      <param-value>false</param-value>
    </init-param>
    <init-param>
      <param-name>cacheName</param-name>
      <param-value>fragmentCache</param-value>
    </init-param>
    
  </filter>

    <!--
        This is a filter chain. They are executed in the order below. Do not
        change the order.
    -->

     <filter-mapping>
    <filter-name>fragmentCache</filter-name>
    <url-pattern>/WEB-INF/pages/tour/tourDetailBody.jsp</url-pattern>
    <dispatcher>INCLUDE</dispatcher> 
    </filter-mapping>

注意，那个<dispatcher>INCLUDE</dispatcher>，不能少，少了缓存不能用。

配置中对应<jsp:include page="/WEB-INF/pages/tour/tourDetailBody.jsp"/>

2.4版本的servlet规范在部属描述符中新增加了一个<dispatcher>元素，这个元素有四个可能的值：即REQUEST,FORWARD,INCLUDE和ERROR，可以在一个<filter-mapping>元素中加入任意数目的<dispatcher>，使得filter将会作用于直接从客户端过来的request，通过forward过来的request，通过include过来的request和通过<error-page>过来的request。如果没有指定任何< dispatcher >元素，默认值是REQUEST。

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="../../main/config/ehcache.xsd">

    <diskStore path="java.io.tmpdir" />

    <defaultCache 
        maxElementsInMemory="10" 
        eternal="false"
        timeToIdleSeconds="5" 
        timeToLiveSeconds="10" 
        overflowToDisk="true" />
    <!--
        maxElementsInMemory="10"内存中的最大页面对象 
        eternal="false"
        timeToIdleSeconds="120" timeToIdleSeconds ，多长时间不访问该缓存，那么ehcache就会清除该缓存。 
        timeToLiveSeconds="240" timeToLiveSeconds，缓存的存活时间，从开始创建的时间算起。
        overflowToDisk="true" 是否写入硬盘
    -->
    <!-- Page and Page Fragment Caches -->

    <cache name="fragmentCache" 
        maxElementsInMemory="10" 
        eternal="false"
        timeToIdleSeconds="10000" 
        timeToLiveSeconds="10000" 
        overflowToDisk="true">
    </cache>
</ehcache>

数据的更新问题：

和页面缓存一样的，根据配置文件中的cacheName获取Ehcache,再根据获取的key进行remove操作。

action中的问题：当页面请求发生时，会调用action方法，这时我们因为先方法，应该先查询cache中是否有缓存fragment存在，如果有，直接返回成功页面，如果没有则执行剩下的代

 <filter>
    <filter-name>CachePage1CachingFilter</filter-name>
    <filter-class>net.sf.ehcache.constructs.web.filter.SimplePageCachingFilter
    </filter-class>
    <init-param>
      <param-name>suppressStackTraces</param-name>
      <param-value>false</param-value>
    </init-param>
    <init-param>
      <param-name>cacheName</param-name>
      <param-value>CachePage1CachingFilter</param-value>
    </init-param>
  </filter>

  <filter>
    <filter-name>SimplePageFragmentCachingFilter</filter-name>
    <filter-class>net.sf.ehcache.constructs.web.filter.SimplePageFragmentCachingFilter
    </filter-class>
    <init-param>
      <param-name>suppressStackTraces</param-name>
      <param-value>false</param-value>
    </init-param>
    <init-param>
      <param-name>cacheName</param-name>
      <param-value>SimplePageFragmentCachingFilter</param-value>
    </init-param>
  </filter>

  <filter>
    <filter-name>SimpleCachingHeadersPageCachingFilter</filter-name>
    <filter-class>net.sf.ehcache.constructs.web.filter.SimpleCachingHeadersPageCachingFilter
    </filter-class>
    <init-param>
      <param-name>suppressStackTraces</param-name>
      <param-value>false</param-value>
    </init-param>
    <init-param>
      <param-name>cacheName</param-name>
      <param-value>CachedPage2Cache</param-value>
    </init-param>

  </filter>

  <!-- This is a filter chain. They are executed in the order below.
  Do not change the order. -->
  <filter-mapping>
    <filter-name>CachePage1CachingFilter</filter-name>
    <url-pattern>/CachedPage.jsp</url-pattern>
    <dispatcher>REQUEST</dispatcher>
    <dispatcher>INCLUDE</dispatcher>
    <dispatcher>FORWARD</dispatcher>
  </filter-mapping>

  <filter-mapping>
    <filter-name>SimplePageFragmentCachingFilter</filter-name>
    <url-pattern>/include/Footer.jsp</url-pattern>
  </filter-mapping>

  <filter-mapping>
    <filter-name>SimplePageFragmentCachingFilter</filter-name>
    <url-pattern>/fragment/CachedFragment.jsp</url-pattern>
  </filter-mapping>

  <filter-mapping>
    <filter-name>SimpleCachingHeadersPageCachingFilter</filter-name>
    <url-pattern>/CachedPage2.jsp</url-pattern>
  </filter-mapping>

<Ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../../main/config/ehcache.xsd">

    <diskStore path="java.io.tmpdir"/>


    <defaultCache
            maxElementsInMemory="10"
            eternal="false"
            timeToIdleSeconds="5"
            timeToLiveSeconds="10"
            overflowToDisk="true"
            />



    <!-- Page and Page Fragment Caches -->

    <cache name="CachePage1CachingFilter"
           maxElementsInMemory="10"
           eternal="false"
           timeToIdleSeconds="10000"
           timeToLiveSeconds="10000"
           overflowToDisk="true">
    </cache>

    <cache name="CachedPage2Cache"
           maxElementsInMemory="10"
           eternal="false"
           timeToLiveSeconds="3600"
           overflowToDisk="true">
    </cache>

    <cache name="SimplePageFragmentCachingFilter"
           maxElementsInMemory="10"
           eternal="false"
           timeToIdleSeconds="10000"
           timeToLiveSeconds="10000"
           overflowToDisk="true">
    </cache>

    <cache name="SimpleCachingHeadersTimeoutPageCachingFilter"
           maxElementsInMemory="10"
           eternal="false"
           timeToIdleSeconds="10000"
           timeToLiveSeconds="10000"
           overflowToDisk="true">
    </cache>

</ehcache>

<!--

            maxElementsInMemory="10"内存中的最大页面对象
            eternal="false"
            timeToIdleSeconds="120"   timeToIdleSeconds ，多长时间不访问该缓存，那么ehcache 就会清除该缓存。           
            timeToLiveSeconds="240" timeToLiveSeconds ，缓存的存活时间，从开始创建的时间算起。
            overflowToDisk="true"     是否写入硬盘

-->
    <!-- Page and Page Fragment Caches -->

    <cache name="show"
           maxElementsInMemory="10"
           eternal="false"
           timeToIdleSeconds="30"
           timeToLiveSeconds="60"
           overflowToDisk="true">
    </cache>

这里只有一个cache,在ehcache即对应一个Ehcache对象,由CacheManager（单例模式实现）去管理，在CacheManager里用配置文件中的name可以获取Ehcache对象的实例。
代码如下:
Ehcache cache = CacheManager.getInstance().getEhcache(cacheName);

展示页面有很多，比如一个商家一个展示页面，即show.action?showId=1后面的数字是可变的，在ehcache里面是用map去存储的，比如show.action?showId=1对应的key为：
GET/show.actionshowId=1
GET为访问方式，把问号去掉了，ehcache内部也是这样存储的（类似map），这样保证了请求的页面在内存中的唯一性，获取也快。
既然key都知道了，删除就好了，直接 查看api文档Ehcache里有很多remove方法。示例代码如下：
Ehcache cache = CacheManager.getInstance().getEhcache(cacheName);
  if (null == cache) {
   return;
  }
  cache.remove(key);

key的获取就不用多说了吧，当更新一个页面的数据时，肯定知道数据的id，直接字符串处理下就可以获取key了，这里注意下就是，代码编写时，一般url里都有项目的名字，正式发布时，肯定没有，而前者在ehcache里生成key里有项目的名字，即：
GET/projetName/show.actionshowId=1
所以最好用spring注入值，到时改也方便。

更详细的，请查看api文档和测试下，官方文档给的都是对象的，页面缓存的给的比较少，我也是查看源码才得出上面代码。
记一下，希望帮助有需求的人。

<action name="Logon" class="tutorial.Logon">
<result type="redirectAction">Menu</result>
</action>

如果你确定两件对象之间是is-a的关系，那么此时你应该使用继承；比如菱形、圆形和方形都是形状的一种，那么他们都应该从形状类继承而不是聚合。
如果你确定两件对象之间是has-a的关系，那么此时你应该使用聚合；比如电脑是由显示器、CPU、硬盘等组成的，那么你应该把显示器、CPU、硬盘这些类聚合成电脑类，而不是从电脑类继承。

网上关于此类的讨论非常多，发现对于该问题的理解各有各的说法，而各个说法中又相去甚远。通过浏览这些讨论以及对《O'Reilly - UML 2.0 In A Nutshell (2007)》的参考，发表一下自己的看法

类间关系有很多种，在大的类别上可以分为两种：纵向关系、横向关系。

纵向关系就是继承关系，它的概念非常明确，也成为OO的三个重要特征之一，这里不过多的讨论。

横向关系较为微妙，按照UML的建议大体上可以分为四种：

2. 依赖    （Dependency）uses a
   
3. 关联    （Association）has a
   
4. 聚合    （Aggregation）owns a
   
5. 组合    （Composition）is a part of 

它们的强弱关系是没有异议的：依赖 < 关联 < 聚合 < 组合

然而它们四个之间的差别却又不那么好拿捏，需要好好体会。

1. 依赖：
   • UML表示法：虚线 + 箭头
     
   • 关系：" ... uses a ..."
   • 此关系最为简单，也最好理解，所谓依赖就是某个对象的功能依赖于另外的某个对象，而被依赖的对象只是作为一种工具在使用，而并不持有对它的引用。
   • 典型的例子很多，比如：
     class Human
     {
         public void breath()
         {
             Air freshAir = new Air();
             freshAir.releasePower();
         }
         public static void main()
         {
             Human me = new Human();
             while(true)
             {
                 me.breath();
             }
         }
     }
     
     class Air
     {
         public void releasePower()
         {
             //do sth.
         }
     }
      
   • 释义：一个人自创生就需要不停的呼吸，而人的呼吸功能之所以能维持生命就在于吸进来的气体发挥了作用，所以说空气只不过是人类的一个工具，而人并不持有对它的引用。
2. 关联：
   • UML表示法：实线 + 箭头
     
   • 关系：" ... has a ..."
   • 所谓关联就是某个对象会长期的持有另一个对象的引用，而二者的关联往往也是相互的。关联的两个对象彼此间没有任何强制性的约束，只要二者同意，可以随时解 除关系或是进行关联，它们在生命期问题上没有任何约定。被关联的对象还可以再被别的对象关联，所以关联是可以共享的。
   • 典型的例子很多，比如：
     class Human
     {
         ArrayList friends = new ArrayList();
         public void makeFriend(Human human)
         {
             friends.add(human);
         }
         public static void main()
         {
             Human me = new Human();
             while(true)
             {
                 me.makeFriend(mySchool.getStudent());
             }
         }
     }
     
   • 释义：人从生至死都在不断的交朋友，然而没有理由认为朋友的生死与我的生死有必然的联系，故他们的生命期没有关联，我的朋友又可以是别人的朋友，所以朋友可以共享。
3. 聚合：  
   • UML表示法：空心菱形 + 实线 + 箭头
     
   • 关系：" ... owns a ..."
   • 聚合是强版本的关联。它暗含着一种所属关系以及生命期关系。被聚合的对象还可以再被别的对象关联，所以被聚合对象是可以共享的。虽然是共享的，聚合代表的是一种更亲密的关系。
   • 典型的例子很多，比如：
     class Human
     {
         Home myHome;
         public void goHome()
         {
             //在回家的路上
             myHome.openDoor();
             //看电视
         }
         public static void main()
         {
             Human me = new Human();
             while(true)
             {
                 //上学
                 //吃饭
                 me.goHome();
             }
         }
     }
      
   • 释义：我的家和我之间具有着一种强烈的所属关系，我的家是可以分享的，而这里的分享又可以有两种。其一是聚合间的分享，这正如你和你媳妇儿都对这个家有着同样的强烈关联；其二是聚合与关联的分享，如果你的朋友来家里吃个便饭，估计你不会给他配一把钥匙。
4. 组合：
   • UML表示法：实心菱形 + 实线 + 箭头
     
   • 关系：" ... is a part of  ..."
   • 组合是关系当中的最强版本，它直接要求包含对象对被包含对象的拥有以及包含对象与被包含对象生命期的关系。被包含的对象还可以再被别的对象关联，所以被包含对象是可以共享的，然而绝不存在两个包含对象对同一个被包含对象的共享。
   • 典型的例子很多，比如：
     class Human
     {
         Heart myHeart = new Heart();
         public static void main()
         {
             Human me = new Human();
             while(true)
             {
                 myHeart.beat();
             }
         }
     }
     
   • 释义：组合关系就是整体与部分的关系，部分属于整体，整体不存在，部分一定不存在，然而部分不存在整体是可以存在的，说的更明确一些就是部分必须创生于整 体创生之后，而销毁于整体销毁之前。部分在这个生命期内可以被其它对象关联甚至聚合，但有一点必须注意，一旦部分所属于的整体销毁了，那么与之关联的对象 中的引用就会成为空引用，这一点可以利用程序来保障。心脏的生命期与人的生命期是一致的，如果换个部分就不那么一定，比如阑尾，很多人在创生后的某个时间 对其厌倦便提前销毁了它，可它和人类的关系不可辩驳的属于组合。
     在UML中存在一种特例，就是允许被包含对象在包含对象销毁前转移给新的对象，这虽然不自然，但它给需要心脏移植的患者带来了福音。

• 依赖(dependency)是一种使用关系，他描述一个事物的规约变化可能影响到使用它的另一个事物。个人认为在参数或者方法体中使用到另外的类就是对该类有依赖的关系。use a
  
• 泛化(dependency)用于描述子类到父类之间的关系。 Is a kind of
  
• 关联(association)是一种结构关系，他描述一个对象与另一个对象相联系。 Has a
  • 双向关联(association)通过A对象可以找到B对象，B对象同样可以找到A对象的关联为双向关联。
    
  • 单向关联(direction-association)通过A对象可以找到B对象，但通过B对象不能找到A对象的关联为单向关联。
    
  • 聚合(aggreation)A对象是B对象的一个组成部份，但A对象同时可能是C对象的组成部分这种关联为聚合。
    
  • 组合(composition)A对象是B对象的一个组成部份，除非B对象将A对象转交给其他对象，否则A对象只能是B对象的组成部分，这种关联为组合。
    

<script type='text/javascript'>
/////ajax登录js
    function showLogin() {
        $('ajaxLogin').style.display = 'block';
    }
    function onSuccessfulLogin(url) {
        //alert(url);
        document.form1.action=url;
        document.form1.submit();
    }

    function authAjax() {
        var form = document.ajaxLoginForm;
        var params = Form.serialize(form)
                + '&spring-security-redirect=/login/ajaxSuccess';
        //Form.disable(form);
        new Ajax.Request(form.action, {
            method : 'POST',
            postBody : params,
            onSuccess : function(response) {
                var responseText = response.responseText || '[]';
                var json = responseText.evalJSON();
                if (json.success) {
                    //alert("ok");
                    onSuccessfulLogin(json.url);
                } else if (json.error) {
                    alert(json.error);
                    Form.enable(document.ajaxLoginForm);
                } else {
                    Element.update('loginMessage', responseText);
                    Form.enable(document.ajaxLoginForm);
                }
            }
        });
    }
</script>

def ajaxSuccess = {
        nocache(response)
        def config = authenticateService.securityConfig.security
        def postUrl = "${request.contextPath}${config.defaultTargetUrl}"
        render "{success: true,url:'${postUrl}'}"//这里返回的是json
    }



def authfail = {

        def username = session[AuthenticationProcessingFilter.SPRING_SECURITY_LAST_USERNAME_KEY]
        def msg = ''
        def exception = session[AbstractProcessingFilter.SPRING_SECURITY_LAST_EXCEPTION_KEY]
        if (exception) {
            if (exception instanceof DisabledException) {
                msg = "[$username] 用户被禁用."
            }
            else {
                msg = "[$username] 错误的用户名或密码."
            }
        }

        if (isAjax()) {
            render "{error: '${msg}'}"
        }
        else {
            flash.message = msg
            redirect action: auth, params: params
        }
    }

<form id="form1" name="form1" target="_blank"></form>

<form action='${request.contextPath}/j_spring_security_check'

    method='POST' id='ajaxLoginForm' name='ajaxLoginForm' target="_blank">

用户名<input id="j_username" name="j_username" type="text" />   

密&nbsp;&nbsp;&nbsp;&nbsp;码<input name="j_password" id="j_password" type="password" /><input onclick='authAjax(); return false;'type="image" src="login.jpg" />

</form>


暂时想不起来为什么用两个form呢，最后引入js:<g:javascript library="prototype" />

ailas(别名)每个keystore都关联这一个独一无二的alias，这个alias通常不区分大小写

JDK中keytool常用命令:

-genkey      在用户主目录中创建一个默认文件".keystore",还会产生一个mykey的别名，mykey中包含用户的公钥、私钥和证书
(在没有指定生成位置的情况下,keystore会存在用户系统默认目录，如：对于window xp系统，会生成在系统的C:\Documents and Settings\UserName\文件名为“.keystore”)
-alias       产生别名
-keystore    指定密钥库的名称(产生的各类信息将不在.keystore文件中)
-keyalg      指定密钥的算法 (如 RSA  DSA（如果不指定默认采用DSA）)
-validity    指定创建的证书有效期多少天
-keysize     指定密钥长度
-storepass   指定密钥库的密码(获取keystore信息所需的密码)
-keypass     指定别名条目的密码(私钥的密码)
-dname       指定证书拥有者信息 例如：  "CN=名字与姓氏,OU=组织单位名称,O=组织名称,L=城市或区域名称,ST=州或省份名称,C=单位的两字母国家代码"
-list        显示密钥库中的证书信息      keytool -list -v -keystore 指定keystore -storepass 密码
-v           显示密钥库中的证书详细信息
-export      将别名指定的证书导出到文件  keytool -export -alias 需要导出的别名 -keystore 指定keystore -file 指定导出的证书位置及证书名称 -storepass 密码
-file        参数指定导出到文件的文件名
-delete      删除密钥库中某条目          keytool -delete -alias 指定需删除的别  -keystore 指定keystore  -storepass 密码
-printcert   查看导出的证书信息          keytool -printcert -file yushan.crt
-keypasswd   修改密钥库中指定条目口令    keytool -keypasswd -alias 需修改的别名 -keypass 旧密码 -new  新密码  -storepass keystore密码  -keystore sage
-storepasswd 修改keystore口令      keytool -storepasswd -keystore e:\yushan.keystore(需修改口令的keystore) -storepass 123456(原始密码) -new yushan(新密码)
-import      将已签名数字证书导入密钥库  keytool -import -alias 指定导入条目的别名 -keystore 指定keystore -file 需导入的证书

下面是各选项的缺省值。 
-alias "mykey"

-keyalg "DSA"

-keysize 1024

-validity 90

-keystore 用户宿主目录中名为 .keystore 的文件

-file 读时为标准输入，写时为标准输出
          


1、keystore的生成：

分阶段生成：
     keytool -genkey -alias yushan(别名) -keypass yushan(别名密码) -keyalg RSA(算法) -keysize 1024(密钥长度) -validity 365(有效期，天单位) -keystore        

e:\yushan.keystore(指定生成证书的位置和证书名称) -storepass 123456(获取keystore信息的密码)；回车输入相关信息即可；
    
一次性生成：
     keytool -genkey -alias yushan -keypass yushan -keyalg RSA -keysize 1024 -validity 365 -keystore  e:\yushan.keystore -storepass 123456 -dname "CN=(名字与

姓氏), OU=(组织单位名称), O=(组织名称), L=(城市或区域名称), ST=(州或省份名称), C=(单位的两字母国家代码)";(中英文即可)

2、keystore信息的查看：
   keytool -list  -v -keystore e:\keytool\yushan.keystore -storepass 123456
   显示内容：
---------------------------------------------------------------------
   Keystore 类型： JKS
Keystore 提供者： SUN

您的 keystore 包含 1 输入

别名名称： yushan
创建日期： 2009-7-29
项类型: PrivateKeyEntry
认证链长度： 1
认证 [1]:
所有者:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
签发人:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
序列号:4a6f29ed
有效期: Wed Jul 29 00:40:13 CST 2009 至Thu Jul 29 00:40:13 CST 2010
证书指纹:
         MD5:A3:D7:D9:74:C3:50:7D:10:C9:C2:47:B0:33:90:45:C3
         SHA1:2B:FC:9E:3A:DF:C6:C4:FB:87:B8:A0:C6:99:43:E9:4C:4A:E1:18:E8
         签名算法名称:SHA1withRSA
         版本: 3
--------------------------------------------------------------------

缺省情况下，-list 命令打印证书的 MD5 指纹。而如果指定了 -v 选项，将以可读格式打印证书，如果指定了 -rfc 选项，将以可打印的编码格式输出证书。

keytool -list  -rfc -keystore e:\yushan.keystore -storepass 123456

显示：

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

Keystore 类型： JKS
Keystore 提供者： SUN

您的 keystore 包含 1 输入

别名名称： yushan
创建日期： 2009-7-29
项类型: PrivateKeyEntry
认证链长度： 1
认证 [1]:
-----BEGIN CERTIFICATE-----
MIICSzCCAbSgAwIBAgIESm8p7TANBgkqhkiG9w0BAQUFADBqMQ8wDQYDVQQGDAbkuK3lm70xDzAN
BgNVBAgMBua5luWNlzEPMA0GA1UEBwwG5rmY5r2tMREwDwYDVQQKDAh4eOWNj+S8mjERMA8GA1UE
CwwIeHjlhazlj7gxDzANBgNVBAMTBnl1c2hhbjAeFw0wOTA3MjgxNjQwMTNaFw0xMDA3MjgxNjQw
MTNaMGoxDzANBgNVBAYMBuS4reWbvTEPMA0GA1UECAwG5rmW5Y2XMQ8wDQYDVQQHDAbmuZjmva0x
ETAPBgNVBAoMCHh45Y2P5LyaMREwDwYDVQQLDAh4eOWFrOWPuDEPMA0GA1UEAxMGeXVzaGFuMIGf
MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCJoru1RQczRzTnBWxefVNspQBykS220rS8Y/oX3mZa
hjL4wLfOURzUuxxuVQR2jx7QI+XKME+DHQj9r6aAcLBCi/T1jwF8mVYxtpRuTzE/6KEZdhowEe70
liWLVE+hytLBHZ03Zhwcd6q5HUMu27du3MPQvqiwzTY7MrwIvQQ8iQIDAQABMA0GCSqGSIb3DQEB
BQUAA4GBAGoQQ1/FnTfkpQh+Ni6h3fZdn3sR8ZzDMbOAIYVLAhBb85XDJ8QZTarHbZMJcIdHxAl1
i08ct3E8U87V9t8GZFWVC4BFg/+zeFEv76SFpVE56iX7P1jpsu78z0m69hHlds77VJTdyfMSvtXv
sYHP3fxfzx9WyhipBwd8VPK/NgEP
-----END CERTIFICATE-----

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

3、证书的导出：

keytool -export -alias yushan -keystore e:\yushan.keystore -file e:\yushan.crt(指定导出的证书位置及证书名称) -storepass 123456

4、查看导出的证书信息
   keytool -printcert -file yushan.crt
   显示：（在windows下可以双击yushan.crt查看）
-----------------------------------------------------------------------
所有者:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
签发人:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
序列号:4a6f29ed
有效期: Wed Jul 29 00:40:13 CST 2009 至Thu Jul 29 00:40:13 CST 2010
证书指纹:
         MD5:A3:D7:D9:74:C3:50:7D:10:C9:C2:47:B0:33:90:45:C3
         SHA1:2B:FC:9E:3A:DF:C6:C4:FB:87:B8:A0:C6:99:43:E9:4C:4A:E1:18:E8
         签名算法名称:SHA1withRSA
         版本: 3
-----------------------------------------------------------------------

5、证书的导入：
   准备一个导入的证书：
   keytool -genkey -alias shuany -keypass shuany -keyalg RSA -keysize 1024 -validity 365 -keystore  e:\shuany.keystore -storepass 123456 -dname "CN=shuany,

OU=xx, O=xx, L=xx, ST=xx, C=xx";
   keytool -export -alias shuany -keystore e:\shuany.keystore -file e:\shuany.crt -storepass 123456
 
  现在将shuany.crt 加入到yushan.keystore中：
  keytool -import -alias shuany(指定导入证书的别名，如果不指定默认为mykey,别名唯一，否则导入出错) -file e:\shuany.crt -keystore e:\yushan.keystore -storepass

123456

 keytool -list  -v -keystore e:\keytool\yushan.keystore -storepass 123456
显示：
------------------------------------------------------------------------------
Keystore 类型： JKS
Keystore 提供者： SUN

您的 keystore 包含 2 输入

别名名称： yushan
创建日期： 2009-7-29
项类型: PrivateKeyEntry
认证链长度： 1
认证 [1]:
所有者:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
签发人:CN=yushan, OU=xx公司, O=xx协会, L=湘潭, ST=湖南, C=中国
序列号:4a6f29ed
有效期: Wed Jul 29 00:40:13 CST 2009 至Thu Jul 29 00:40:13 CST 2010
证书指纹:
         MD5:A3:D7:D9:74:C3:50:7D:10:C9:C2:47:B0:33:90:45:C3
         SHA1:2B:FC:9E:3A:DF:C6:C4:FB:87:B8:A0:C6:99:43:E9:4C:4A:E1:18:E8
         签名算法名称:SHA1withRSA
         版本: 3


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


别名名称： shuany
创建日期： 2009-7-29
输入类型： trustedCertEntry

所有者:CN=shuany, OU=xx, O=xx, L=xx, ST=xx, C=xx
签发人:CN=shuany, OU=xx, O=xx, L=xx, ST=xx, C=xx
序列号:4a6f2cd9
有效期: Wed Jul 29 00:52:41 CST 2009 至Thu Jul 29 00:52:41 CST 2010
证书指纹:
         MD5:15:03:57:9B:14:BD:C5:50:21:15:47:1E:29:87:A4:E6
         SHA1:C1:4F:8B:CD:5E:C2:94:77:B7:42:29:35:5C:BB:BB:2E:9E:F0:89:F5
         签名算法名称:SHA1withRSA
         版本: 3


*******************************************
*******************************************
------------------------------------------------------------------------------

6、证书条目的删除：
 keytool -delete -alias shuany(指定需删除的别名) -keystore yushan.keystore -storepass 123456
 
7、证书条目口令的修改：
keytool -keypasswd -alias yushan(需要修改密码的别名) -keypass yushan(原始密码) -new 123456(别名的新密码)  -keystore e:\yushan.keystore -storepass 123456

8、keystore口令的修改：
 keytool -storepasswd -keystore e:\yushan.keystore(需修改口令的keystore) -storepass 123456(原始密码) -new yushan(新密码)

9、修改keystore中别名为yushan的信息

keytool -selfcert -alias yushan -keypass yushan -keystore e:\yushan.keystore -storepass 123456 -dname "cn=yushan,ou=yushan,o=yushan,c=us"

系统

# uname -a               # 查看内核/操作系统/CPU信息
# head -n 1 /etc/issue   # 查看操作系统版本
# cat /proc/cpuinfo      # 查看CPU信息
# hostname               # 查看计算机名
# lspci -tv              # 列出所有PCI设备
# lsusb -tv              # 列出所有USB设备
# lsmod                  # 列出加载的内核模块
# env                    # 查看环境变量

资源

# free -m                # 查看内存使用量和交换区使用量
# df -h                  # 查看各分区使用情况
# du -sh <目录名>        # 查看指定目录的大小
# grep MemTotal /proc/meminfo   # 查看内存总量
# grep MemFree /proc/meminfo    # 查看空闲内存量
# uptime                 # 查看系统运行时间、用户数、负载
# cat /proc/loadavg      # 查看系统负载

磁盘和分区

# mount | column -t      # 查看挂接的分区状态
# fdisk -l               # 查看所有分区
# swapon -s              # 查看所有交换分区
# hdparm -i /dev/hda     # 查看磁盘参数(仅适用于IDE设备)
# dmesg | grep IDE       # 查看启动时IDE设备检测状况

网络

# ifconfig               # 查看所有网络接口的属性
# iptables -L            # 查看防火墙设置
# route -n               # 查看路由表
# netstat -lntp          # 查看所有监听端口
# netstat -antp          # 查看所有已经建立的连接
# netstat -s             # 查看网络统计信息

进程

# ps -ef                 # 查看所有进程
# top                    # 实时显示进程状态

用户

# w                      # 查看活动用户
# id <用户名>            # 查看指定用户信息
# last                   # 查看用户登录日志
# cut -d: -f1 /etc/passwd   # 查看系统所有用户
# cut -d: -f1 /etc/group    # 查看系统所有组
# crontab -l             # 查看当前用户的计划任务

服务

# chkconfig --list       # 列出所有系统服务
# chkconfig --list | grep on    # 列出所有启动的系统服务

程序

# rpm -qa                # 查看所有安装的软件包

1. 在LINUX命令平台输入1-2个字符后按Tab键会自动补全后面的部分(前提是要有这个东西，例如在装了tomcat的前提下,输入tomcat的to按tab)。

2. ps 命令用于查看当前正在运行的进程。

    grep 是搜索

   例如： ps -ef | grep java

                 表示查看所有进程里CMD是java的进程信息

                 ps -aux | grep java

                 -aux 显示所有状态

                 ps

3. kill 命令用于终止进程

   例如： kill -9 [PID]                

                 -9表示强迫进程立即停止

通常用ps 查看进程PID ，用kill命令终止进程

网上关于这两块的内容

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

PS

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

1. ps简介
ps命令就是最根本相应情况下也是相当强大地进程查看命令.运用该命令可以确定有哪些进程正在运行和运行地状态、进程是否结束、进程有没有僵死、哪些进程占用了过多地资源等等.总之大部分信息均为可以通过执行该命令得到地.
2. ps命令及其参数
ps命令最经常使用地还是用于监控后台进程地工作情况,因为后台进程是不和屏幕键盘这些标准输入/输出设
备进行通信地,所以如果需要检测其情况,便可以运用ps命令了.
该命令语法格式如下：
ps [选项]
-e 显示所有进程,环境变量
-f 全格式
-h 不显示标题
-l 长格式
-w 宽输出
a   显示终端上地所有进程,包括其他用户地进程
r   只显示正在运行地进程
x   显示没有控制终端地进程
O[+|-] k1 [,[+|-] k2 [,…]] 根据SHORT KEYS、k1、k2中快捷键指定地多级排序顺序显示进程列表.
对于ps地不同格式都存在着默认地顺序指定.这些默认顺序可以被用户地指定所覆盖.在这里面“+”字符是可选地,“-”字符是倒转指定键地方向.
pids只列出进程标识符,之间运用逗号分隔.该进程列表必须在命令行参数地最后一个选项后面紧接着给出,中间不能插入空格.比如：ps -f1,4,5.
以下介绍长命令行选项,这些选项都运用“--”开头：
--sort X[+|-] key [,[+|-] key [,…]] 从SORT KEYS段中选一个多字母键.“+”字符是可选地,因为默认地方向就是按数字升序或者词典顺序.比如： ps -jax -sort=uid,-ppid,+pid.
--help 显示帮助信息.
--version 显示该命令地版本信息.
在前面地选项说明中提到了排序键,接下来对排序键作进一步说明.需要注意地是排序中运用地值是ps运用地内部值,并非仅用于某些输出格式地伪值.排序键列表见表4-3.
表4-3　排序键列表
c
cmd
可执行地简单名称
C
cmdline
完整命令行
f
flags
长模式标志
g
pgrp
进程地组ID
G
tpgid
控制tty进程组ID
j
cutime
累计用户时间
J
cstime
累计系统时间
k
utime
用户时间
K
stime
系统时间
m
min_flt
次要页错误地数量
M
maj_flt
重点页错误地数量
n
cmin_flt
累计次要页错误
N
cmaj_flt
累计重点页错误
o
session
对话ID
p
pid
进程ID
P
ppid
父进程ID
r
rss
驻留大小
R
resident
驻留页
s
size
内存大小(千字节)
S
share
共享页地数量
t
tty
tty次要设备号
T
start_time
进程启动地时间
U
uid
UID
u
user
用户名
v
vsize
总地虚拟内存数量(字节)
y
priority
内核调度优先级
3. 经常使用ps命令参数
最经常使用地三个参数是u、a、x,下面将通过例子来说明其具体用法.
[例20] 以root身份登录系统,查看当前进程状况
$ ps
PID TTY TIME COMMAND
5800 ttyp0 00:00:00 bash
5835 ttyp0 00:00:00 ps
可以看到,显示地项目共分为四项,依次为PID(进程ID)、TTY(终端名称)、TIME(进程执行时间)
、COMMAND(该进程地命令行输入).
可以运用u选项来查看进程所有者及其他少许详细信息,如下所示：
$ ps u
USER PID %CPU %MEM USZ RSS TTY STAT START TIME COMMAND
test 5800 0.0 0.4 1892 1040 ttyp0 S Nov27 0:00 -bash
test 5836 0.0 0.3 2528 856 ttyp0 R Nov27 0:00 ps u
在bash进程前面有条横线,意味着该进程便是用户地登录shell,所以对于一个登录用户来说带短横线地进程只有一个.还可以看到%CPU、%MEM两个选项,前者指该进程占用地CPU时间和总时间地百分比;后者指该进程占用地内存和总内存地百分比.
在这种情况下看到了所有控制终端地进程;当然对于其他那些没有控制终端地进程还是没有观察到,所以这时就需要运用x选项.运用x选项可以观察到所有地进程情况.

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

KILL

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

由于职责的要求，你不得不费力地阅读那些令你感到费解的晦涩的Linux应用程序的说明文件。然后，你将运行指令和编辑设置文件。一切都在正常运行，生活真美好。但是，你知道，好时光不会永远持续下去。当你遇到令人恐惧的“send the process a SIGHUP”提示时，好时光结束了。

　　什么是“SIGHUP（启动信号）”，你如何发送它?它像是你送给你的恋人的一束花吗?虽然你可以肯定这不是一个命令行指令，不过，你还是试着键入它。当然，这没有结果。然后，你检查一下键盘。哦，没有SIGHUP键。于是你又重新阅读这个应用程序的参考指南，看到下面这段文字:

　　当收到一个hangup（进程结束）信号时，sshd程序会重新阅读配置文件。通过执行启动程序时的命令及选项来发送SIGHUP信号，如:/usr/sbin/sshd。

　　哦，原来是这样。

　　程序员 VS 使用者

　　LINUX程序的在线参考指南作者一般都要既照顾到最终用户的需求也要照顾到高级程序员的需求。因此，有些说明比较难懂。不过，不要担心。现在我们就要揭开覆盖在这些让人迷惑的内容上面那神秘的面纱。

　　信号与进程控制

　　这个问题主要属于信号和进程控制的范畴。对于我们系统管理员和普通用户来说，我们主要关心的是启动、停止和重新启动服务、停止失控的进程和被挂起的进程，并且尽可能不中断系统运行。因为不同的

操作系统和不同的命令外壳处理信号的方式都不相同，我们这里只介绍Linux操作系统和bash外壳。

　　信号是用来与守护程序和进程通信的。任何活动任务都是一个进程，而守护程序是等待对某些事件做出反应或者按照日程安排执行任务的后台服务。一个程序必须有建在其中的信号处理程序用于捕获和应答信号。在LINUX中的signal 参考指南解释了各种不同信号和这些信号的用途。信号是由“kill”命令发出的。kill -l命令可以显示一个可用信号列表及其编号。

　　所有的守护程序和进程都有一个进程ID(PID)，例如使用ps命名所显示的内容：

　　$ ps aux
　　USER PID %CPU %MEM TTY STAT COMMAND
　　root 1 0.0 0.1 ? S init [2]
　　105 7783 0.0 0.2 ? Ss /usr/bin/dbus-daemon --system
　　hal 7796 0.0 0.7 ? Ss /usr/sbin/hald
　　postfix 7957 0.0 0.2 ? S qmgr -l -t fifo -u -c
　　nagios 8371 0.0 0.2 ? SNs /usr/sbin/nagios /etc/nagios/nagios.cfg

　　这个输出是经过简化的。你在系统中可以看到更多的行和栏目。如果某些进程消耗了你的全部CPU或者内存，你可以在这个输出的%CPU和%MEM列中发现它们。找到失控的进程的一种更快捷的方法是使用top命令，因为按照默认的设置，使用占用CPU资源最多的进程在最上面显示。我们可以使用一条“yes”命令来测试一下:

$ yes carla is teh awesum

　　这个命令将以很高的速度反复显示“carla is teh awesum”，直到你停止它运行。这将使你的CPU使用率达到警戒线。

　　$ top
　　...
　　PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
　　12144 carla 25 0 31592 17m 13m R 93.4 3.5 0:50.26 konsole
　　22236 carla 15 0 2860 468 400 S 4.3 0.1 0:00.97 yes

分析一下这个结果，你会发现一些有趣的事，你会发现，占用CPU最多的程序是konsole虚拟终端程序，而不是“yes”命令，这是因为“yes”命令是在konsole终端程序中运行的。如果在一个“真正的”控制台(按Ctrl+alt+f2键)中运行同样的命令序列，你将看到“yes”命令被排在第一位。

　　有许多停止“yes”命令运行的方式。如果你要回到运行它的shell中，按CTRL+c键就可以了。或者你可以在另一个shell中用“kill”命令停止“yes”命令的运行，Kill命令后面跟PID或者命令名称，如下如示:

$ kill 22236

　　或者

$ killall yes

　　按CTRL+c键发出一个SIGINT（信号2），这个信号是键盘要求取得控制权的中断信号。kill和killall这两个命令按照默认的设置都发出一个SIGTERM信号(编号15)。程序中可以设置对SIGTERM信号(15)是捕捉或者忽略，或者以不同的方式解释。因此，如果你的程序对于KILL命令的反应与你预期不同，很可能是被KILL的目标程序的问题。

　　终止一个父进程通常也终止了它的子进程。不过，情况并不总是如此。你知道子进程是什么吗?使用ps命令加上-f选项就可以看到，如下所示:

　　$ ps axf
　　22371 ? R 2:35 _ konsole [kdeinit]
　　22372 pts/3 Ss 0:00 | _ /bin/bash
　　24322 pts/3 S+ 0:00 | | _ yes carla is teh awesum
　　22381 pts/4 Rs 0:00 | _ /bin/bash
　　24323 pts/4 R+ 0:00 | | _ ps axf

　　现在，回到SIGHUP的话题

　　SIGHUP的发音是“sig-hup”，是signal hangup的缩写，含义是“中止信号”。你如何发送一个SIGHUP信号呢?这里有几种方式:

# kill -HUP [pid]

# killall -HUP [process-name]

# kill -1 [pid]

# killall -1 [process-name]

　　因此，你可以使用PID或者名称，信号名称或者号码。那么为什么要这样做而不使用/etc/init.d/foo命令重新启动呢?使用它们自己的init(初始化)文件来控制服务是优先选择的方式，因为这些文件通常包含健全和错误检查以及额外的功能。使用“kill”命令和信号的主要原因是尽可能明确地终止挂起和失控的进程，而不必重新启动或者登出。

终止进程

　　正如你在关于信号的man page中所看到的，有十几种控制进程的方法。下面是一些常用的方法:

　　kill -STOP [pid]

　　发送SIGSTOP (17,19,23)停止一个进程，而并不消灭这个进程。

　　kill -CONT [pid]

　　发送SIGCONT (19,18,25)重新开始一个停止的进程。

　　kill -KILL [pid]

　　发送SIGKILL (9)强迫进程立即停止，并且不实施清理操作。

　　kill -9 -1

　　终止你拥有的全部进程。

　　SIGKILL和SIGSTOP信号不能被捕捉、封锁或者忽略，但是，其它的信号可以。所以这是你的终极武器。

　　Bash shell的Kil命令l

　　Bash外壳包含一个内置的kill命令，当执行下面命令:

　　$ type -all kill
　　kill is a shell built-in
　　kill is /bin/kill

　　命令的结果表明有两个kill命令，一个是BASH的内置命令，另一个是/bin/kill可执行程序。一般来说这两个命令不太可能遇到冲突的情况，不过，如果你确实遇到了kill命令行为异常时，你可以明确的指定/bin/kill命令。

　　你一定要进一步查阅下面的资源中列出的参考资源来了解Linux中kill的妙用，因为这是你进入维护Linux系统领域的门票。这些知识能够让你像做外科手术一样对系统进行维护，而不用在遇到问题时每一次都重新启动系统，就像我们知道的某些蹩脚的

操作系统那样。

　　资源

　　Linux Cookbook一书的第七章“开始和终止Linux”

　　bash (1) - GNU Bourne-Again Shell

　　yes (1) - 在被终止前反复打印字符

　　signal (7) - 可用信号列表

　　ps (1) - 报告当前进程的快照

　　kill (1) - 向一个进程发出信号

　　killall (1) - 按名字消灭进程

　　pkill (1) - 根据名字和其它属性查看或者发出进程信号

　　skill (1) - 发送一个信号或者报告进程状态

　　xkill (1) - 按照X资源消灭一个客户程序

编辑 my.ini linux下为/etc/my.cnf

在[mysqld]的段中加上一句：skip-grant-tables

例如：

[mysqld]

datadir=/var/lib/mysql

socket=/var/lib/mysql/mysql.sock

skip-name-resolve

skip-grant-tables

目的是为了：

跳过MySQL的访问控制，任何人都可以在控制台以管理员的身份进入MySQL数据库。

需要注意的是在修改完密码以后要把MySQL服务器停掉重新启动才会生效

重启mysql服务！

OK!
有时增加用户时提示：
ERROR 1045 (28000): Access denied for user.....
得执行flush privileges;
 
#新加用户服务xcj,新加的用户不能马上生效
mysql> grant all on *.* to xcj@'%' identified by "xcj_passwd";
Query OK, 0 rows affected (0.04 sec)

#生效新加用户xcj权限
mysql> flush privileges;
Query OK, 0 rows affected (0.03 sec)


[root@openfire pdf_spider]# mysql -uxcj -p'xcj_passwd'
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 4593
Server version: 5.0.45-log MySQL Community Server (GPL)

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Fedora 13 如同前作 Fedora 12 一样，默认开启了 Nouveau 的 KMS 模块，尽管已经可以通过 Gallium3D 获得完整 3D 加速支持，但肯定还有一些追求性能和希望用高清视频加速的朋友需要 NVIDIA 的二进制驱动。

本文以使用 rpmfusion 打包的 NVIDIA 的二进制驱动为例，若需要安装 Nvidia 官方站点提供的版本，请参考 Fedora 12 的文章 并依照此文做出相应修改。

1. 添加 rpmfusion 仓库：

su -c 'rpm -Uvh http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm'

2. 使用 yum 安装驱动：

su -c 'yum --nogpgcheck install xorg-x11-drv-nvidia akmod-nvidia'

3. 屏蔽 initrd 中的 nouveau 模块：

su -c 'sed -i '/root=/s|$| rdblacklist=nouveau|' /etc/grub.conf'

4. 重启

非常必要！

在此感谢 FedoraForm 的 leigh123linux 大的 HowTo 。