Nothing is true everything is permitted

linux chmod命令

linux chmod命令参数及用法详解–文件文件夹权限设定命令

使用权限 : 所有使用者
使用方式 : chmod [-cfvR] [–help] [–version] mode file…
说明 : Linux/Unix 的档案存取权限分为三级 : 档案拥有者、群组、其他。利用chmod可以藉以控制档案如何被他人所存取。

mode: 权限设定字串，格式如下 : [ugoa…][[+-=][rwxX]…][,…]，其中u 表示该档案的拥有者，g 表示与该档案的拥有者属于同一个群体(group)者，o 表示其他以外的人，a 表示这三者皆是。

• 表示增加权限、- 表示取消权限、= 表示唯一设定权限。
  r 表示可读取，w 表示可写入，x 表示可执行，X 表示只有当该档案是个子目录或者该档案已经被设定过为可执行。
  -c : 若该档案权限确实已经更改，才显示其更改动作
  -f : 若该档案权限无法被更改也不要显示错误讯息
  -v : 显示权限变更的详细资料
  -R : 对目前目录下的所有档案与子目录进行相同的权限变更(即以递回的方式逐个变更)
  –help : 显示辅助说明
  –version : 显示版本

  1 2 3 4 5 6 7 8 9 10

  //将档案 file1.txt 设为所有人皆可读取 : chmod ugo+r file1.txt //将档案 file1.txt 设为所有人皆可读取 : chmod a+r file1.txt //将档案 file1.txt 与 file2.txt //设为该档案拥有者，与其所属同一个群体者可写入，但其他以外的人则不可写入 : chmod ug+w,o-w file1.txt file2.txt //将 ex1.py 设定为只有该档案拥有者可以执行 : chmod u+x ex1.py //将目前目录下的所有档案与子目录皆设为任何人可读取 : chmod -R a+r *

此外chmod也可以用数字来表示权限如 chmod 777 file
语法为：chmod abc file
其中a,b,c各为一个数字，分别表示User、Group、及Other的权限。
r=4，w=2，x=1
若要rwx属性则4+2+1=7；
若要rw-属性则4+2=6；
若要r-x属性则4+1=7。
范例：

1
2

chmod a=rwx file
chmod 777 file

与下等效

1
2

chmod ug=rwx,o=x file
chmod 771 file

若用chmod 4755 filename可使此程式具有root的权限
指令名称 : chown
使用权限 : root

使用方式 : chmod [-cfhvR] [--help] [--version] user[:group] file...

说明 : Linux/Unix 是多人多工作业系统，所有的档案皆有拥有者。利用 chown 可以将档案的拥有者加以改变。一般来说，这个指令只有是由系统管理者(root)所使用，一般使用者没有权限可以改变别人的档案拥有者，也没有权限可以自己的档案拥有者改设为别人。只有系统管理者(root)才有这样的权限。

user: 新的档案拥有者的使用者 IDgroup : 新的档案拥有者的使用者群体(group)-c : 若该档案拥有者确实已经更改，才显示其更改动作-f : 若该档案拥有者无法被更改也不要显示错误讯息-h : 只对于连结(link)进行变更，而非该 link 真正指向的档案-v : 显示拥有者变更的详细资料-R : 对目前目录下的所有档案与子目录进行相同的拥有者变更(即以递回的方式逐个变更)–help : 显示辅助说明–version : 显示版本

范例 :
//将档案 file1.txt 的拥有者设为 users 群体的使用者 jessie :
chown jessie:users file1.txt

将目前目录下的所有档案与子目录的拥有者皆设为 users 群体的使用者 lamport :
chmod -R lamport:users *
-rw——- (600) – 只有属主有读写权限。

-rw-r–r– (644) – 只有属主有读写权限；而属组用户和其他用户只有读权限。

-rwx—— (700) – 只有属主有读、写、执行权限。

-rwxr-xr-x (755) – 属主有读、写、执行权限；而属组用户和其他用户只有读、执行权限。

-rwx–x–x (711) – 属主有读、写、执行权限；而属组用户和其他用户只有执行权限。

-rw-rw-rw- (666) – 所有用户都有文件读、写权限。这种做法不可取。

-rwxrwxrwx (777) – 所有用户都有读、写、执行权限。更不可取的做法。

以下是对目录的两个普通设定:

drwx—— (700) - 只有属主可在目录中读、写。

drwxr-xr-x (755) - 所有用户可读该目录，但只有属主才能改变目录中的内容
suid的代表数字是4，比如4755的结果是-rwsr-xr-x
sgid的代表数字是2，比如6755的结果是-rwsr-sr-x
sticky位代表数字是1，比如7755的结果是-rwsr-sr-t

SUID与SGID的意义

关于UNIX和Linux系统下SUID、SGID的解析

一、UNIX下关于文件权限的表示方法和解析

SUID 是Set User ID, SGID 是Set Group ID的意思。
UNIX下可以用ls -l 命令来看到文件的权限。用ls命令所得到的表示法的格式是类似这样的：-rwxr-xr-x 。下面解析一下格式所表示的意思。这种表示方法一共有十位：

1
2

9 8 7 6 5 4 3 2 1 0
- r w x r - x r - x

第9位表示文件类型,可以为p、d、l、s、c、b和-：
p表示命名管道文件
d表示目录文件
l表示符号连接文件
-表示普通文件
s表示socket文件
c表示字符设备文件
b表示块设备文件

第8-6位、5-3位、2-0位分别表示文件所有者的权限，同组用户的权限，其他用户的权限，其形式为rwx：
r表示可读，可以读出文件的内容
w表示可写，可以修改文件的内容
x表示可执行，可运行这个程序
没有权限的位置用-表示
例子：

1
2

ls -l myfile显示为：
-rwxr-x--- 1 foo staff 7734 Apr 05 17:07 myfile

表示文件myfile是普通文件，文件的所有者是foo用户，而foo用户属于staff组，文件只有1个硬连接，长度是7734个字节，最后修改时间4月5日17:07。
所有者foo对文件有读写执行权限，staff组的成员对文件有读和执行权限，其他的用户对这个文件没有权限。
如果一个文件被设置了SUID或SGID位，会分别表现在所有者或同组用户的权限的可执行位上。例如：
1、-rwsr-xr-x 表示SUID和所有者权限中可执行位被设置
2、-rwSr–r– 表示SUID被设置，但所有者权限中可执行位没有被设置
3、-rwxr-sr-x 表示SGID和同组用户权限中可执行位被设置
4、-rw-r-Sr– 表示SGID被设置，但同组用户权限中可执行位没有被社

其实在UNIX的实现中，文件权限用12个二进制位表示，如果该位置上的值是
1，表示有相应的权限：

1
2

11 10 9 8 7 6 5 4 3 2 1 0
S G T r w x r w x r w x

第11位为SUID位，第10位为SGID位，第9位为sticky位，第8-0位对应于上面的三组rwx位。
11 10 9 8 7 6 5 4 3 2 1 0
上面的-rwsr-xr-x的值为： 1 0 0 1 1 1 1 0 1 1 0 1
-rw-r-Sr–的值为： 0 1 0 1 1 0 1 0 0 1 0 0

给文件加SUID和SUID的命令如下：

1
2
3
4

chmod u+s filename 设置SUID位
chmod u-s filename 去掉SUID设置
chmod g+s filename 设置SGID位
chmod g-s filename 去掉SGID设置

另外一种方法是chmod命令用八进制表示方法的设置。如果明白了前面的12位权限表示法也很简单。

二、SUID和SGID的详细解析

由于SUID和SGID是在执行程序（程序的可执行位被设置）时起作用，而可执行位只对普通文件和目录文件有意义，所以设置其他种类文件的SUID和SGID位是没有多大意义的。

首先讲普通文件的SUID和SGID的作用。例子：
如果普通文件myfile是属于foo用户的，是可执行的，现在没设SUID位，ls命令显示如下：

1

-rwxr-xr-x 1 foo staff 7734 Apr 05 17:07

myfile任何用户都可以执行这个程序。UNIX的内核是根据什么来确定一个进程对资源的访问权限的呢？是这个进程的运行用户的（有效）ID，包括user id和group id。用户可以用id命令来查到自己的或其他用户的user id和group id。
除了一般的user id 和group id外，还有两个称之为effective 的id，就是有效id，上面的四个id表示为：uid，gid，euid，egid。内核主要是根据euid和egid来确定进程对资源的访问权限。
一个进程如果没有SUID或SGID位，则euid=uid egid=gid，分别是运行这个程序的用户的uid和gid。例如kevin用户的uid和gid分别为204和202，foo用户的uid和gid为200，201，kevin运行myfile程序形成的进程的euid=uid=204，egid=gid=202，内核根据这些值来判断进程对资源访问的限制，其实就是kevin用户对资源访问的权限，和foo没关系。
如果一个程序设置了SUID，则euid和egid变成被运行的程序的所有者的uid和gid，例如kevin用户运行myfile，euid=200，egid=201，uid=204，gid=202，则这个进程具有它的属主foo的资源访问权限。

SUID的作用就是这样：让本来没有相应权限的用户运行这个程序时，可以访问他没有权限访问的资源。passwd就是一个很鲜明的例子。
SUID的优先级比SGID高，当一个可执行程序设置了SUID，则SGID会自动变成相应的egid。

下面讨论一个例子：
UNIX系统有一个/dev/kmem的设备文件，是一个字符设备文件，里面存储了核心程序要访问的数据，包括用户的口令。所以这个文件不能给一般的用户读写，权限设为：cr--r----- 1 root system 2, 1 May 25 1998 kmem

但ps等程序要读这个文件，而ps的权限设置如下：
-r-xr-sr-x 1 bin system 59346 Apr 05 1998 ps
这是一个设置了SGID的程序，而ps的用户是bin，不是root，所以不能设置SUID来访问kmem，但大家注意了，bin和root都属于system组，而且ps设置了SGID，一般用户执行ps，就会获得system组用户的权限，而文件kmem的同组用户的权限是可读，所以一般用户执行ps就没问题了。但有些人说，为什么不把ps程序设置为root用户的程序，然后设置SUID位，不也行吗？这的确可以解决问题，但实际中为什么不这样做呢？因为SGID的风险比SUID小得多，所以出于系统安全的考虑，应该尽量用SGID代替SUID的程序，如果可能的话。下面来说明一下SGID对目录的影响。SUID对目录没有影响。如果一个目录设置了SGID位，那么如果任何一个用户对这个目录有写权限的话，他在这个目录所建立的文件的组都会自动转为这个目录的属主所在的组，而文件所有者不变，还是属于建立这个文件的用户。

三、关于SUID和SGID的编程

和SUID和SGID编程比较密切相关的有以下的头文件和函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include
#include
uid_t getuid(void);
uid_t geteuid(void);
gid_t getgid (void);
gid_t getegid (void);
int setuid (uid_t UID);
int setruid (uid_t RUID);
int seteuid (uid_t EUID);
int setreuid (uid_t RUID,uid_t EUID);
int setgid (gid_t GID);
int setrgid (gid_t RGID);
int setegid (git_t EGID);
int setregid (gid_t RGID, gid_t EGID);

具体这些函数的说明在这里就不详细列出来了,要用到的可以用man查。
SUID/SGID :

假如你有文件a.txt

1
2
3
4
5
6
7
8

#ls -l a.txt
-rwxrwxrwx
#chmod 4777 a.txt
-rwsrwxrwx ======>注意s位置
#chmod 2777 a.txt
-rwxrwsrwx ======>注意s位置
#chmod 7777 a.txt
-rwsrwxswt ======>出现了t,t的作用在内存中尽量保存a.txt,节省系统再加载的时间.

现在再看前面设置 SUID/SGID作用:

1
2
3
4
5
6
7
8
9
10
11

#cd /sbin
#./lsusb
...
#su aaa(普通用户)
$./lsusb
...
是不是现在显示出错？
$su
#chmod 4755 lsusb
#su aaa
$./lsusb

… 现在明白了吗？本来是只有root用户才能执行的命令，加了SUID后,普通用户就可以像root一样的用，权限提升了。上面是对于文件来说的，对于目录也差不多！

目录的S属性使得在该目录下创建的任何文件及子目录属于该目录所拥有的组，目录的T属性使得该目录的所有者及root才能删除该目录。还有对于s与S，设置SUID/SGID需要有运行权限，否则用ls -l后就会看到S,证明你所设置的SUID/SGID没有起作用。

Why we need suid,how do we use suid?

r – 读访问
w – 写访问
x – 执行许可
s – SUID/SGID
t – sticky位

那么 suid/sgid是做什么的？ 为什么会有suid位呢？

要想明白这个，先让我们看个问题：如果让每个用户更改自己的密码？
用户修改密码，是通过运行命令passwd来实现的。最终必须要修改/etc/passwd文件，而passwd的文件的属性是：

1
2

#ls -l /etc/passwd
-rw-r--r-- 1 root root 2520 Jul 12 18:25 passwd

我们可以看到passwd文件只有对于root用户是可写的，而对于所有的他用户来说都是没有写权限的。 那么一个普通的用户如何能够通过运行passwd命令修改这个passwd文件呢？
为了解决这个问题，SUID/SGID便应运而生。而且AT&T对它申请了专利。 呵呵。

SUID和SGID是如何解决这个问题呢？
首先，我们要知道一点：进程在运行的时候，有一些属性，其中包括 实际用户ID,实际组ID,有效用户ID,有效组ID等。 实际用户ID和实际组ID标识我们是谁，谁在运行这个程序,一般这2个字段在登陆时决定，在一个登陆会话期间， 这些值基本上不改变。
而有效用户ID和有效组ID则决定了进程在运行时的权限。内核在决定进程是否有文件存取权限时，是采用了进程的有效用户ID来进行判断的。

知道了这点，我们来看看SUID的解决途径：
当一个程序设置了为SUID位时，内核就知道了运行这个程序的时候，应该认为是文件的所有者在运行这个程序。即该程序运行的时候，有效用户ID是该程序的所有者。举个例子：

1
2

[root@sgrid5 bin]# ls -l passwd
-r-s--s--x 1 root root 16336 Feb 14 2003 passwd

虽然你以test登陆系统，但是当你输入passwd命令来更改密码的时候，由于passwd设置了SUID位，因此虽然进程的实际用户ID是test对应的ID，但是进程的有效用户ID则是passwd文件的所有者root的ID,因此可以修改/etc/passwd文件。

让我们看另外一个例子。
ping命令应用广泛，可以测试网络是否连接正常。ping在运行中是采用了ICMP协议，需要发送ICMP报文。但是只有root用户才能建立ICMP报文，如何解决这个问题呢？同样，也是通过SUID位来解决。

1
2

[root@sgrid5 bin]# ls -l /bin/ping
-rwsr-sr-x 1 root root 28628 Jan 25 2003 /bin/ping

我们可以测试一下，如果去掉ping的SUID位，再用普通用户去运行命令，看会怎么样。

1
2
3
4
5
6

[root@sgrid5 bin]#chmod u-s /bin/ping
[root@sgrid5 bin]# ls -l ping
-rwxr-xr-x 1 root root 28628 Jan 25 2003 ping
[root@sgrid5 bin]#su test
[test@sgrid5 bin]$ ping byhh.net
ping: icmp open socket: Operation not permitted

SUID虽然很好了解决了一些问题，但是同时也会带来一些安全隐患。
因为设置了 SUID 位的程序如果被攻击(通过缓冲区溢出等方面),那么hacker就可以拿到root权限。
因此在安全方面特别要注意那些设置了SUID的程序。
通过以下的命令可以找到系统上所有的设置了suid的文件：

1

[root@sgrid5 /]# find / -perm -04000 -type f -ls

对于这里为什么是4000，大家可以看一下前面的st_mode的各bit的意义就明白了。
在这些设置了suid的程序里，如果用不上的，就最好取消该程序的suid位。

linux下的部分文件夹命令

linux下文件夹的创建、复制、剪切、重命名、清空和删除命令

• 创建目录： mkdir /home/test, 在home目录下创建一个test文件夹
• 复制目录: cp -rf /home/test1 /home/test2,将test1文件夹复制到test2中，即将test1变成test2的子目录
• 复制目录及文件: cp -rf /home/test1/* /home/test2,将test1及其目录下所有文件都复制到test2中
• 移动/重命名目录及文件： mv /home/test1 /home/test2,如果test2存在则将test1移动至test2中，如果不存在则将test1重命名为test2
• 删除目录: rm -rf /home/test1，删除test1目录，-r为向下递归，即目录下所有子目录及文件；-f为不显示提示。

Ubuntu下安装tar.gz文件

ubuntu如何安装 tar,gz tar.gz2

• tar.gz文件解压命令: sudo tar zxvf file.tar.gz
• bz2文件解压命令: sudo tar jxvf file.tar.bz2或者sudo bzip2 -de file.tar.bz2|tar xvf file.tar.bz2
• tar.Z文件解压命令: sudo uncompress file.tar.Z

解压后编译:

1
2
3

sudo ./configure
make
make install

或者

1
2
3

sudo ./configure --prefix=/路径
make 
make install

又如

1
2
3
4

sudo ./configure --enable-static-link \
--prefix=$XXX/static --with-curses &&
make &&
make install

--enable-static-link: 这个配置命令使bash被静态链接。
--prefix=$XXX/static: 这个配置命令把Bash的所有文件安装到$XXX/static目录下，这个目录在chroot环境下或在最终的XXX系统中将成为/static目录。(XXX为用户）
--with-curses: 将bash链接到某一个库，正如LFS系统将它指向static这一个库。
&&: 使后一个命令仅在前一个命令返回值为0(表示正确执行)的情况下才执行。

Objective-C 基础

声明变量

Object-C @property 小结
IOS，objective_C中用@interface和 @property 方式声明变量的区别
iOS开发中常见的语句@synthesize obj=_obj的意义详解
iOS中属性与成员变量的区别

@property是什么

标识为@property的变量可以自动生成setter与getter方法。
声明: 声明格式为@property (attributes) type propertyName
实现: 在.m文件中的implements下，格式为@synthsize name即可。而在xcode4.4以后的版本，系统会自动合成, 等价于自己写了代码“ @synthesize name = _name;” 。 也就是说如果没有特殊需求，只需要在头文件中声明而无需实现，就可以直接使用了
成员变量访问权限: 头文件中声明的成员变量，默认是protected，.m文件中声明的成员变量，默认是private的。合成属性时，@synthesize propertyName = _name；如果变量_name没有声明，系统会自动生成该成员变量且为private权限。如果_name已声明，它们会自动合成

声明一个属性，如果没有声明为只读的，它默认会生成两个方法 - (type)name 和 - (void)setName; 为了可读性等其它原因，也可以改变属性的setter和getter访问名称

1

@property  (setter=setMyValue, getter=getBool) NSInteger  value;

这样的话就可以通过 [obj setMyValue:10] 和 [obj getBool]方法业访问成员变量了，此时setValue方法会被覆盖，不再存在

@property的修饰属性(attributes)

• 可读性：readwrite / readonly ，不写的话默认为readwrite，即会合成setter和getter方法
• 内存 assign / retain / weak / strong ，在非ARC环境下， assign为默认，引用计数不变；retain引用计数加1；在引用计数环境下，默认为strong，与retain作用相同；从5.0系统后引入了weak，作用与assign相似，不过当所指向对象引用为0时，自动置为nil

Selector基本概念

Selector基本概念和操作

@selector()就是取类方法的编号,他的行为基本可以等同C语言的中函数指针,只不过C语言中，可以把函数名直接赋给一个函数指针，而Objective-C的类不能直接应用函数指针，这样只能做一个@selector语法来取。它的结果是一个SEL类型。这个类型本质是类方法的编号(函数地址)?

引入头文件关键字@Class/#import

IOS开发技术之──头文件引用（@class/#import/#include）
IOS基础：深入理解Objective-c中@class的含义

#include:引入C头文件
#import:引入Objective-C的头文件
@class:类引用

#import确定一个文件只能被导入一次，这使你在递归包含中不会出现问题.#import比起#include的好处就是不会引起交叉编译.
#import方式会包含被引用类的所有信息，包括被引用类的变量和方法；@class方式只是告诉编译器在被引用类只是类的声明，具体这个类里有什么信息，这里不需要知道，等实现文件中真正要用到时，才会真正去查看被引用类中信息。
使用@class方式由于只需要只要被引用类的名称就可以了，而在实现类由于要用到被引用类中的实体变量和方法，所以需要使用#import来包含被引用类的头文件
@class是放在interface中的，只是在引用一个类，将这个被引用类作为一个类型，在实现文件中，如果需要引用到被引用类的实体变量或者方法时，还需要使用#import方式引入被引用类

ivar是什么意思

ObjectiveC基础－ivar是什么意思

Objective-C运行时定义了几种重要的类型。

• class: 定义Objective-C类
• ivar: 定义对象的实例变量，包括类型与名字
• protocol: 定义协议
• objc_property_t: 定义属性
• method: 定义对象方法或者类方法。这个类型提供了方法的名字(选择器),参数类型与数量，返回值(合称为方法签名)，以及指向代码的函数指针(方法的实现)
• SEL: 定义选择器。选择器为方法名唯一的标识
• IMP: 定义方法的实现。这是一个指向某个函数的指针，该函数接受一个对象，一个选择器以及一个可变参数列表，返回一个对象。

Objective-C限定词

Objective-C 限定词 long short 等
objectiveC【语法】修饰符 static extern const

• long: 如果直接把限定词long放在int声明之前，那么所声明的整型变量在某些计算机上具有扩展的值域。例如long int factorial.这条语句将变量factorial声明为long的整型变量，也就是长整型。就象float和double变量一样，long变量的具体精度是由具体的计算机系统决定的。在许多系统上，int与long int具有相同的值域，而且任何一个都能存储4个字节(1个字节8位)，32位宽(2,147,483,647)的整型值。long在限定整型的时候，实际相当于双精度的short。
  long int类型的常量值可通过在整型常量末尾添加字母L(大小写均可)来形成。单数字和L之间不允许由空格。因为小写的L和数字1容易混淆，建议有用到这种情况，都用大写。要用NSLog显示long int的值，使用字母l做为修饰符并放在整型格式符号i，o和x之前。例如“%lx”表示十六进制格式显示值。
  当然，我们同样可以把long标识符放在double声明之前。long double常量可写成其尾部带有字母l或L的浮点常量。要显示long double的值，需要使用修饰符L。因此，%Lf用浮点计数法显示long double的值，%Le用科学计数法显示同样的值，而%Lg将告诉NSLog在%Lf和%Le之间任选一个使用。

• long long: 双长整型相当于双精度long，可以用如下形式使用:

  1	long long int maxAllowedStorage;

这条语句把指定的变量声明为具有特定扩展精度的双长整型变量，该扩展精度保证变量至少8个字节，具有64位的宽度。NSLog字符串不使用单个字母l，而使用两个l来显示long long的整数，例如“%lli”

• short: 把限定词short放在int声明之前时，它告诉Objective-C编译器要声明的特定变量用来存储相当小的整数。之所以使用short变量，主要原因是对节约内存空间的考虑，当程序员需要大量内存而可用的内存量又十分有限时，就可用short变量来解决这个问题。在某些计算机上，short int占用的内存空间是常规int变量所占空间的一半。在任何情况下，确保分配给short int的空间数量不少于2个字节，16位
  注意，在Objective-C中，没有其他方法可显式地编写short int型常量。要显示short int变量，可将字母h放在任何普通的整型转换符之前，如%hi，%ho或%hx。换句话说，可用任何整型转换符号来显示short int，因为当它作为参数传递给NSLog例程时，可转换成整数

• unsigned: 这个最终限定词就是无符号，可放在int变量之前，当整数变量只用来存储正数的情况下使用最终限定符。以下语句

  1	unsigned int counter;

向编译器声明：变量counter只用来保存正值。通过限制整型变量的使用，使它专门存储正整数，可以扩展整型变量的精度。一般unsigned int可简写为uint。

• signed: signed限定词可明确地告诉编译器特定变量是有符号的。它主要用在char声明前面。

• const: 修饰的东西不能被修改。指针类型根据位置的不同可以理解成3种情况:
  1.常量指针

  1 2	// 初始化之后不能赋值，指向的对象可以是任意对象，对象可变。 NSString * const pt1;

2.指向常量的指针

1
2

// 初始化之后可以赋值，即指向别的常量，指针本身的值可以修改，指向的值不能修改
const NSString * pt2;

3.指向常量的常量指针

1

const NSString *  const pt3;

• extern: 等同于c，全局变量的定义

  1 2 3 4 5 6 7 8 9 10

  //x .h 声明 extern const NSString * AA; //x .m 定义 const NSString * AA = @"abc"; // 调用 #import "x.h" 或者再次申明 extern const NSString * AA;

• static: 等同于c，将变量的作用域限定于本文件,static变量属于本类，不同的类对应的是不同的对象;static变量同一个类所有对象中共享，只初始化一次。

1. static const变量同static的结论，只是不能修改了，但是还是不同的对象
2. extern const变量只有一个对象，标准的常量的定义方法
3. extern的意思就是这个变量已经定义了，你只负责用就行了

<display:setProperty name="basic.msg.empty_list_row" value=""/> 属性

更改空记录提示语言，默认提示：“没有满足查询条件的记录”

在<display:table....里面 <display:column....前面增加

1
2

<display:setProperty name="basic.msg.empty_list_row" value="没有找到任何记录" />
<display:setProperty name="basic.msg.empty_list" value="没有找到任何记录！" />

空记录提示语言修改为：”没有找到任何记录”

空记录的时候仍然显示表头信息（默认空记录不显示表头信息）

在<display:table....里面 <display:column....前面增加

1
2

<display:setProperty name="basic.msg.empty_list_row" value="" />
<display:setProperty name="basic.empty.showtable" value="true" />

不显示标题，默认为显示=true

1

<display:setProperty name="basic.show.header" value="false" />

按list或page排序，默认按page

1

<display:setProperty name="sort.amount" value="list" />

Hibernate中的实体状态

写得很不错的-Hibernate中的实体状态(一)[转]

Hibernate中实体有三个状态：瞬时、持久化和脱管。下面先来看看Hibernate对这三个状态是怎么定义的。
（1）瞬时：一个实体通过new操作符创建后，没有和Hibernate的Session建立关系，也没有手动赋值过该实体的持久化标识（持久化标识可以认为映射表的主键）。此时该实体中的任何属性的更新都不会反映到数据库表中。
（2）持久化：当一个实体和Hibernate的Session创建了关系，并获取了持久化标识，而且在Hibernate的Session生命周期内存在。此时针对该实体任何属性的更改都会直接影响到数据库表中一条记录对应字段的更新，也即与对应数据库表保持同步。
（3）脱管：当一个实体和Hibernate的Session创建了关系，并获取了持久化标识，而此时Hibernate的Session的生命周期结束，实体的持久化标识没有被改动过。针对该实体的任何属性的修改都不会及时反映到数据库表中。

这三种状态有两个很重要的点需要掌握：Hibernate的Session和持久化标识。通过这两个条件就可以判断出究竟是3种状态中的哪一个。3种不同状态通过Hibernate的Session和持久化标识可以互相之间进行转换

举个简单的例子，假如Room实体的属性id表示持久化标识，那么：
（1）创建的Room实例为瞬时状态，将表中对应的主键手动设置到id属性，此时就是脱管状态。
（2）创建的Room实例为瞬时状态，不设置id或设置的id在表中找不到对应，此时调用Hibernate Session的持久化方法，将成为持久化状态。
（3）Room实体在持久化状态下关闭Hibernate Session，此时就是脱管状态。
（4）Room实体在脱管状态下调用Hibernate Session的持久化方法，此时就是持久化状态。
（5）Room实体在持久化状态下关闭Hibernate Session，随后清除id属性的值，此时就是瞬时状态。

实体状态的代码实现：瞬时—持久化

从瞬时状态到持久化状态，Hibernate提供了如下的实现，见例6.1（以下代码省略了配置映射文件的部分）。

瞬时—持久化的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public void run() {
     //创建瞬时状态的UserInf实例
     UserInfo userInfo = new UserInfo();
     //设置UserInfo属性，持久化标识id属性在映射中为自增长，不用设置
     userInfo.setName("RW");
     userInfo.setSex("M");
     //启动Session
     Session session = HibernateSessionFactory.currentSession();
     //启动事务
     Transaction tx = session.beginTransaction();
     //瞬时—持久化的实现，保存UserInfo代表的一条记录到数据库
     session.save(userInfo);
     //对持久化的UserInfo进行属性的更新，此时将同步数据库
     userInfo.setName("RW2");
     userInfo.setSex("F");
     //不用调用update方法，持久化状态的UserInfo会自动同步数据库
     //提交事务
     tx.commit();
     //关闭Hibernate Session
     HibernateSessionFactory.closeSession();

}

针对该段代码将执行如下SQL语句：

1
2
3
4

/* session.save(userInfo);的动作 */
insert into userinfo(NAME, SEX, roomid, id)values(?, ?, ?, ?)
/* userInfo.setName("RW2"); userInfo.setSex("F"); 的动作*/
update userinfo set NAME=?,SEX=?,roomid=? where id=?

当瞬时状态转变为持久化状态时，需要自行调用持久化方法（如：session.save()）来执行SQL。而在持久化状态时，Hibernate控制器会自动侦测到改动，执行SQL同步数据库。

实体状态的代码实现：脱管-持久化、持久化-脱管

从脱管状态和持久化状态双重转变，Hibernate提供了如下的实现
脱管状态和持久化状态双重转变

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public void run() {
      //创建UserInfo实例
      UserInfo userInfo = new UserInfo();
      //启动Session
      Session session = HibernateSessionFactory.currentSession();
      //启动事务
      Transaction tx = session.beginTransaction();
      //得到持久化UserInfo，此时UserInfo为持久化状态
      //与数据库中主键为11117的记录同步
      session.load(userInfo,new Long(11117));
      //提交事务
      tx.commit();
      //关闭Hibernate Session
      HibernateSessionFactory.closeSession();
      //关闭Hibernate Session后UserInfo的状态为脱管状态
      //此时依然能够得到数据库在持久化状态时的数据
      //对userInfo实体的属性的操作将不影响数据库中主键为11117的记录
      userInfo.setName("RW3");
      userInfo.setSex("M");
      //启动Session
      session = HibernateSessionFactory.currentSession();
      //启动事务
      tx = session.beginTransaction();
      //从脱管状态到持久化状态的转变，此时将更新数据库中对应主键为11117的记录
      session.update(userInfo);
      //提交事务
      tx.commit();
      //关闭Hibernate Session
      HibernateSessionFactory.closeSession();
 }

针对该段代码将执行如下SQL语句：

1
2
3
4
5
6
7
8
9
10
11
12

/* session.load(userInfo,new Long(11117))的动作 */
select 
        userinfo0_.id as id0_0_,
        userinfo0_.NAME as NAME0_0_,
        userinfo0_.SEX as SEX0_0_,
        userinfo0_.roomid as roomid0_0_
    from
        userinfo userinfo0_
    where
        userinfo0_.id=?
/* session.update(userInfo)的动作 */
update userinfo set NAME=?, SEX=?, roomid=? where id=?

可以看到userInfo.setName("RW3")这一部分的代码没有直接同步数据库的表，因为此时Hibernate Session已经关闭了，此时是脱管状态。而直到再次打开Hibernate Session并调用session.update(userInfo)，此时由于持久化标识存在于UserInfo实例，因此将从脱管状态转变为持久化状态，同步数据库。

持久化方法对状态的影响

在Hibernate中定义了多个持久化方法，这些方法的调用对实体状态是有影响的。注意，并不是每一个持久化方法都会将实体状态变为持久化状态。在之前的代码中，已经使用到的持久化方法为session.save()、session.load()、session.update()。下面是另外一些持久化方法的调用方式。

（1）session.delete()方法
该方法将已经存在的表记录删除，其所影响的状态是从持久化、脱管状态转变为瞬时状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public void run() {
     //创建UserInfo实例
     UserInfo userInfo = new UserInfo();
     //启动Session
     Session session = HibernateSessionFactory.currentSession();
     //启动事务
     Transaction tx = session.beginTransaction();
     //得到持久化UserInfo，此时UserInfo为持久化状态
     //与数据库中主键为11117的记录同步
     session.load(userInfo,new Long(11117));
     //删除持久化状态的UserInfo实体，此时UserInfo实体为瞬时状态
     session.delete(userInfo);
     //提交事务
     tx.commit();
     //关闭Hibernate Session
     HibernateSessionFactory.closeSession();
     //由于执行了session.delete因此UserInfo实体为瞬时状态，在数据库中找不到主键为11117的数据
     //此时依然能够显示该实体的属性
     System.out.println("---Id:" + userInfo.getId());
     System.out.println("---Name:" + userInfo.getName());
     System.out.println("---Sex:" + userInfo.getSex());
     //更新UserInfo实体的持久化标识，使其成为脱管状态
     userInfo.setId(11116);
     //启动Session
     session = HibernateSessionFactory.currentSession();
     //启动事务
     tx = session.beginTransaction();
     //调用delete方法将脱管状态的UserInfo实体转变为瞬时状态
     session.delete(userInfo);
     //提交事务
     tx.commit();
     //关闭Hibernate Session
     HibernateSessionFactory.closeSession();
}

针对该段代码将执行如下SQL语句：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/* session.load(userInfo,new Long(11117))的动作 */
select
        userinfo0_.id as id0_0_,
        userinfo0_.NAME as NAME0_0_,
        userinfo0_.SEX as SEX0_0_,
        userinfo0_.roomid as roomid0_0_
    from
        userinfo userinfo0_
    where
        userinfo0_.id=?
/* session.delete(userInfo)的动作 */
delete
        from
            userinfo
        where
            id=?
/* session.delete(userInfo)的动作 */
delete
        from
            userinfo
        where
            id=?

可以看到，两句delete语句分别对应了持久化状态的UserInfo和脱管状态的UserInfo的删除动作。之后两种状态的UserInfo都会成为瞬时状态。

创建表时先判断是否已存在

oracle（PL/SQL）表操作：创建表时检查数据库是否存在该表，若存在删除再创建

使用sql 2005 来执行“创建表之前判断表是否存在 如果有就删除表，再创建”的操作语句非常简单

1
2
3
4

if exists (
select * from sysobjects 
where id = OBJECT_ID('STUDENTS]') and OBJECTPROPERTY(id, 'IsUserTable') = 1) 
DROP TABLE [STUDENTS]

PL/SQL中

1
2
3
4
5
6
7
8
9
10
11
12
13

declare 
  cnt number;
begin
  --查询要创建的表是否存在
  select count(*)into cnt from user_tables where table_name='STUDENTS';
  if cnt>0 then
    execute immediate 'drop table STUDENTS';
    dbms_output.put_line('表存在，删除成功!');
  end if;
  ---删除之后再创建该表
  execute immediate 
    'CREATE TABLE STUDENTS(SNAME CHAR (8) NOT NULL) tablespace Users' ;
end;

GCD是Grand Central Dispatch的简称,它是基于C语言的。如果使用GCD，完全由系统管理线程，我们不需要编写线程代码。只需定义想要执行的任务,然后添加到适当的调度队列(dispatch queue)。GCD会负责创建线程和调度你的任务，系统直接提供线程管理

收集一些平时使用Tomcat碰到的问题。

收集平时碰到的一些小问题的解决方法。

收集一些平时在iOS开发中碰到的问题解决方法