月度归档:2015年11月

Spring缓存注解@Cache使用

参考资料

http://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/

http://swiftlet.net/archives/774

缓存注解有以下三个:

@Cacheable @CacheEvict @CachePut

@Cacheable(value=”accountCache”), 这个注释的意思是,当调用这个方法的时候,会从一个名叫 accountCache 的缓存中查询,如果没有,则执行实际的方法(即查询数据库),并将执行的结果存入缓存中,否则返回缓存中的对象。这里的缓存中的 key 就是参数 userName,value 就是 Account 对象。“accountCache”缓存是在 spring*.xml 中定义的名称。

  1. @Cacheable(value="accountCache")// 使用了一个缓存名叫 accountCache
  2. public Account getAccountByName(String userName) {
  3. // 方法内部实现不考虑缓存逻辑,直接实现业务
  4. System.out.println("real query account."+userName);
  5. return getFromDB(userName);
  6. }

 

@CacheEvict 注释来标记要清空缓存的方法,当这个方法被调用后,即会清空缓存。注意其中一个 @CacheEvict(value=”accountCache”,key=”#account.getName()”),其中的 Key 是用来指定缓存的 key 的,这里因为我们保存的时候用的是 account 对象的 name 字段,所以这里还需要从参数 account 对象中获取 name 的值来作为 key,前面的 # 号代表这是一个 SpEL 表达式,此表达式可以遍历方法的参数对象,具体语法可以参考 Spring 的相关文档手册。

  1. @CacheEvict(value="accountCache",key="#account.getName()")// 清空accountCache 缓存
  2. public void updateAccount(Account account) {
  3. updateDB(account);
  4. }
  5. @CacheEvict(value="accountCache",allEntries=true)// 清空accountCache 缓存
  6. public void reload() {
  7. reloadAll()
  8. }
  9. @Cacheable(value="accountCache",condition="#userName.length() <=4")// 缓存名叫 accountCache
  10. public Account getAccountByName(String userName) {
  11. // 方法内部实现不考虑缓存逻辑,直接实现业务
  12. return getFromDB(userName);
  13. }

@CachePut 注释,这个注释可以确保方法被执行,同时方法的返回值也被记录到缓存中,实现缓存与数据库的同步更新。

示例:

  1. @CachePut(value="accountCache",key="#account.getName()")// 更新accountCache 缓存
  2. public Account updateAccount(Account account) {
  3. return updateDB(account);
  4. }

@Cacheable、@CachePut、@CacheEvict 注释介绍

通过上面的例子,我们可以看到 spring cache 主要使用两个注释标签,即 @Cacheable、@CachePut 和 @CacheEvict,我们总结一下其作用和配置方法。

表 1. @Cacheable 作用和配置方法

@Cacheable 的作用 主要针对方法配置,能够根据方法的请求参数对其结果进行缓存

@Cacheable 主要的参数
value缓存的名称,在 spring 配置文件中定义,必须指定至少一个例如:
@Cacheable(value=”mycache”) 或者
@Cacheable(value={”cache1”,”cache2”}
key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合例如:
@Cacheable(value=”testcache”,key=”#userName”)
condition缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存例如:
@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
表 2. @CachePut 作用和配置方法

@CachePut 的作用 主要针对方法配置,能够根据方法的请求参数对其结果进行缓存,和 @Cacheable 不同的是,它每次都会触发真实方法的调用

@CachePut 主要的参数
value缓存的名称,在 spring 配置文件中定义,必须指定至少一个例如:
@Cacheable(value=”mycache”) 或者
@Cacheable(value={”cache1”,”cache2”}
key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合例如:
@Cacheable(value=”testcache”,key=”#userName”)
condition缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存例如:
@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
表 3. @CacheEvict 作用和配置方法

@CachEvict 的作用 主要针对方法配置,能够根据一定的条件对缓存进行清空

@CacheEvict 主要的参数
value缓存的名称,在 spring 配置文件中定义,必须指定至少一个例如:
@CachEvict(value=”mycache”) 或者
@CachEvict(value={”cache1”,”cache2”}
key缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合例如:
@CachEvict(value=”testcache”,key=”#userName”)
condition缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才清空缓存例如:
@CachEvict(value=”testcache”,
condition=”#userName.length()>2”)
allEntries是否清空所有缓存内容,缺省为 false,如果指定为 true,则方法调用后将立即清空所有缓存例如:
@CachEvict(value=”testcache”,allEntries=true)
beforeInvocation是否在方法执行前就清空,缺省为 false,如果指定为 true,则在方法还没有执行的时候就清空缓存,缺省情况下,如果方法执行抛出异常,则不会清空缓存例如:
@CachEvict(value=”testcache”,beforeInvocation=true)

 

淘宝分布式配置管理服务Diamond

来源:http://www.kuqin.com/shuoit/20141013/342587.html

在一个分布式环境中,同类型的服务往往会部署很多实例。这些实例使用了一些配置,为了更好地维护这些配置就产生了配置管理服务。通过这个服务可以轻松地管理这些应用服务的配置问题。应用场景可概括为:

zookeeper的一种应用就是分布式配置管理(基于ZooKeeper的配置信息存储方案的设计与实现)。百度也有类似的实现:disconf。

Diamond则是淘宝开源的一种分布式配置管理服务的实现。Diamond本质上是一个Java写的Web应用,其对外提供接口都是基于HTTP协议的,在阅读代码时可以从实现各个接口的controller入手。

分布式配置管理

分布式配置管理的本质基本上就是一种推送-订阅模式的运用。配置的应用方是订阅者,配置管理服务则是推送方。概括为下图:

其中,客户端包括管理人员publish数据到配置管理服务,可以理解为添加/更新数据;配置管理服务notify数据到订阅者,可以理解为推送。

配置管理服务往往会封装一个客户端库,应用方则是基于该库与配置管理服务进行交互。在实际实现时,客户端库可能是主动拉取(pull)数据,但对于应用方而言,一般是一种事件通知方式。

Diamond中的数据是简单的key-value结构。应用方订阅数据则是基于key来订阅,未订阅的数据当然不会被推送。数据从类型上又划分为 聚合和非聚合。因为数据推送者可能很多,在整个分布式环境中,可能有多个推送者在推送相同key的数据,这些数据如果是聚合的,那么所有这些推送者推送的 数据会被合并在一起;反之如果是非聚合的,则会出现覆盖。

数据的来源可能是人工通过管理端录入,也可能是其他服务通过配置管理服务的推送接口自动录入。

架构及实现

Diamond服务是一个集群,是一个去除了单点的协作集群。如图:

图中可分为以下部分讲解:

服务之间同步

Diamond服务集群每一个实例都可以对外完整地提供服务,那么意味着每个实例上都有整个集群维护的数据。Diamond有两种方式保证这一点:

  • 任何一个实例都有其他实例的地址;任何一个实例上的数据变更时,都会将改变的数据同步到mysql上,然后通知其他所有实例从mysql上进行一次数据拉取(DumpService::dump),这个过程只拉取改变了的数据
  • 任何一个实例启动后都会以较长的时间间隔(几小时),从mysql进行一次全量的数据拉取(DumpAllProcessor)

实现上为了一致性,通知其他实例实际上也包含自己。以服务器收到添加聚合数据为例,处理过程大致为:

DatumController::addDatum // /datum.do?method=addDatum     PersistService::addAggrConfigInfo      MergeDatumService::addMergeTask // 添加一个MergeDataTask,异步处理  MergeTaskProcessor::process     PersistService::insertOrUpdate         EventDispatcher.fireEvent(new ConfigDataChangeEvent // 派发一个ConfigDataChangeEvent事件  NotifyService::onEvent // 接收事件并处理     TaskManager::addTask(..., new NotifyTask // 由此,当数据发生变动,则最终创建了一个NoticyTask  // NotifyTask同样异步处理 NotifyTaskProcessor::process     foreach server in serverList // 包含自己         notifyToDump // 调用 /notify.do?method=notifyConfigInfo 从mysql更新变动的数据 

虽然Diamond去除了单点问题,不过问题都下降到了mysql上。但由于其作为配置管理的定位,其数据量就mysql的应用而言算小的了,所以可以一定程度上保证整个服务的可用性。

数据一致性

由于Diamond服务器没有master,任何一个实例都可以读写数据,那么针对同一个key的数据则可能面临冲突。这里应该是通过mysql来 保证数据的一致性。每一次客户端请求写数据时,Diamond都将写请求投递给mysql,然后通知集群内所有Diamond实例(包括自己)从 mysql拉取数据。当然,拉取数据则可能不是每一次写入都能拉出来,也就是最终一致性。

Diamond中没有把数据放入内存,但会放到本地文件。对于客户端的读操作而言,则是直接返回本地文件里的数据。

服务实例列表

Diamond服务实例列表是一份静态数据,直接将每个实例的地址存放在一个web server上。无论是Diamond服务还是客户端都从该web server上取出实例列表。

对于客户端而言,当其取出了该列表后,则是随机选择一个节点(ServerListManager.java),以后的请求都会发往该节点。

数据同步

客户端库中以固定时间间隔从服务器拉取数据(ClientWorker::ClientWorkerClientWorker::checkServerConfigInfo)。只有应用方关心的数据才可能被拉取。另外,为了数据推送的及时,Diamond还使用了一种long polling的技术,其实也是为了突破HTTP协议的局限性。如果整个服务是基于TCP的自定义协议,客户端与服务器保持长连接则没有这些问题

数据的变更

Diamond中很多操作都会检查数据是否发生了变化。标识数据变化则是基于数据对应的MD5值来实现的。

容灾

在整个Diamond系统中,几个角色为了提高容灾性,都有自己的缓存,概括为下图:

每一个角色出问题时,都可以尽量保证客户端对应用层提供服务。

参考文档

Maven中mirror和repository区别

maven介绍

Maven是基于项目对象模型(POM),可以通过一小段描述信息来管理项目的构建,报告和文档的软件项目管理工具。
Maven 除了以程序构建能力为特色之外,还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性,所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法,许多 Apache Jakarta 项目发文时使用 Maven,而且公司项目采用 Maven 的比例在持续增长。
Maven这个单词来自于意第绪语,意为知识的积累,最早在Jakata Turbine项目中它开始被用来试图简化构建过程。当时有很多项目,它们的Ant build文件仅有细微的差别,而JAR文件都由CVS来维护。于是Maven创始者开始了Maven这个项目,该项目的清晰定义包括,一种很方便的发布项目信息的方式,以及一种在多个项目中共享JAR的方式

maven常用命令

mvn archetype:create 创建Maven项目
mvn compile 编译源代码
mvn deploy 发布项目
mvn test-compile 编译测试源代码
mvn test 运行应用程序中的单元测试
mvn site 生成项目相关信息的网站
mvn clean 清除项目目录中的生成结果
mvn package 根据项目生成的jar
mvn install 在本地Repository中安装jar
mvn eclipse:eclipse 生成eclipse项目文件
mvnjetty:run 启动jetty服务
mvntomcat:run 启动tomcat服务
mvn clean package -Dmaven.test.skip=true:清除以前的包后重新打包,跳过测试类

国内可用maven的镜像

由于maven主要仓库在国外, 因此国内访问比较慢, 因此在maven安装好后, 可以配置一下国内的 镜像,如下:

<mirrors>
<mirror>
<id>nexus-osc</id>
<mirrorOf>central</mirrorOf>
<name>Nexus osc</name>
<url>http://maven.oschina.net/content/groups/public/</url>
</mirror>
<mirror>
<id>nexus-osc-thirdparty</id>
<mirrorOf>thirdparty</mirrorOf>
<name>Nexus osc thirdparty</name>
<url>http://maven.oschina.net/content/repositories/thirdparty/</url>
</mirror>
</mirrors>

经过测试, 确实比较快。

maven仓库和镜像关系

来源:http://my.oschina.net/sunchp/blog/100634?fromerr=bhhiOmYn

1 Repository(仓库)

1.1 Maven仓库主要有2种:

  • remote repository:相当于公共的仓库,大家都能访问到,一般可以用URL的形式访问
  • local repository:存放在本地磁盘的一个文件夹,例如,windows上默认是C:\Users\{用户名}\.m2\repository目录

1.2 Remote Repository主要有3种:

  • 中央仓库:http://repo1.maven.org/maven2/
  • 私服:内网自建的maven repository,其URL是一个内部网址
  • 其他公共仓库:其他可以互联网公共访问maven repository,例如 jboss repository等

repository里存放的都是各种jar包和maven插件。当向仓库请求插件或依赖的时候,会先检查local repository,如果local repository有则直接返回,否则会向remote repository请求,并缓存到local repository。也可以把做的东西放到本地仓库,仅供本地使用;或上传到远程仓库,供大家使用。

2 Mirror

mirror相当于一个拦截器,它会拦截maven对remote repository的相关请求,把请求里的remote repository地址,重定向到mirror里配置的地址。

2.1 没有配置mirror:

2.2 配置mirror:

此时,B Repository被称为A Repository的镜像。

如果仓库X可以提供仓库Y存储的所有内容,那么就可以认为X是Y的一个镜像。换句话说,任何一个可以从仓库Y获得的构件,都胡够从它的镜像中获取。

2.3 <mirrorOf></mirrorOf> 

<mirrorOf></mirrorOf>标签里面放置的是要被镜像的Repository ID。为了满足一些复杂的需求,Maven还支持更高级的镜像配置:

  • <mirrorOf>*</mirrorOf> 

匹配所有远程仓库。

  • <mirrorOf>repo1,repo2</mirrorOf> 

匹配仓库repo1和repo2,使用逗号分隔多个远程仓库。

  • <mirrorOf>*,!repo1</miiroOf> 

匹配所有远程仓库,repo1除外,使用感叹号将仓库从匹配中排除。
3 Repository与Mirror

3.1 定义

其 实,mirror表示的是两个Repository之间的关系,在maven配置文件(setting.xml)里配置 了<mirrors><mirror>..........</mirror></mirrors>, 即定义了两个Repository之间的镜像关系。

3.2 目的

配置两个Repository之间的镜像关系,一般是出于访问速度和下载速度考虑。

例 如, 有一个项目,需要在公司和住所都编码,并在项目pom.xml配置了A Maven库。在公司,是电信网络,访问A库很快,所以maven管理依赖和插件都从A库下载;在住所,是网通网络,访问A库很慢,但是访问B库很快。这 时,在住所的setting.xml里,只要配置一 下<mirrors><mirror>....</mirror></mirrors>,让B库成为A 库的mirror,即可不用更改项目pom.xml里对于A库的相关配置。

如果该镜像仓库需要认证,则配置setting.xml中的<server></server>即可。

3.3  注意

需要注意的是,由于镜像仓库完全屏蔽了被镜像仓库,当镜像仓库不稳定或者停止服务的时候,Maven仍将无法访问被镜像仓库,因而将无法下载构件。

4 私服

私服是一种特殊的远程Maven仓库,它是架设在局域网内的仓库服务,私服一般被配置为互联网远程仓库的镜像,供局域网内的Maven用户使用。

当Maven需要下载构件的时候,先向私服请求,如果私服上不存在该构件,则从外部的远程仓库下载,同时缓存在私服之上,然后为Maven下载请求提供下载服务,另外,对于自定义或第三方的jar可以从本地上传到私服,供局域网内其他maven用户使用。

优点主要有:

  1. 节省外网宽带
  2. 加速Maven构建
  3. 部署第三方构件
  4. 提高稳定性、增强控制:原因是外网不稳定
  5. 降低中央仓库的负荷:原因是中央仓库访问量太大

PS:Maven仓库示意图

解决MAVEN内存溢出

Windows环境中

找到文件%M2_HOME%\bin\mvn.bat ,这就是启动Maven的脚本文件,在该文件中你能看到有一行注释为:

@REM set MAVEN_OPTS=-Xdebug -Xnoagent -Djava.compiler=NONE...

它的意思是你可以设置一些Maven参数,我们就在注释下面加入一行:
set MAVEN_OPTS= -Xms128m -Xmx512m

之后,当你运行Maven命令如 mvn -version 的时候,你会看到如下的输出:
E:\test>mvn -version

E:\test>set MAVEN_OPTS= -Xms128m -Xmx512m
Maven version: 2.0.9
Java version: 1.6.0_07
OS name: "windows 2003" version: "5.2" arch: "x86" Family: "windows"

我们看到,配置的Maven选项生效了,OutOfMemoryError也能得以相应的解决。

Linux环境中

也可以通过设置环境变量解决该问题, 如,编辑文件 /etc/profile 如下
MAVEN_OPTS=-Xmx512m
export JAVA_HOME MAVEN_HOME MAVEN_OPTS JAVA_BIN PATH CLASSPATH

如果你使用Hudson

用 Hudson + Maven做持续集成,并不幸也遇到了类似的错误,那么上述两种方式都将不再起作用了,因为Hudson使用自己的maven-agent来启动Maven,不会去调用Maven的脚本,自然相应的配置也就无效了。

好在Hudson也给为我们提供了配置点,在Hudson的项目配置页面中,有一块Build区域,这里我们已经设置了Root Pom和Goals。注意该区域的右下角有一个"Advanced..."按钮,点击会看到MAVEN_OPTS输入框,这里输入"-Xmx512m"就 OK了。

m2eclipse中

类似以上的方法都会失效,所幸m2eclipse提供了配置点。步骤如下:

项目上右击 -> Run As -> Run Configurations -> Maven Build 上右击 -> New

这时会看到一个maven运行配置对话框,这里面其它的配置我不多解释了,为了解决内存溢出的问题,我们可以选择第二个TAB: JRE,然后在VM arguments中输入配置如:-Xms128m -Xmx512m。

转自 http://blog.sina.com.cn/u/1743752000

Linux的shell比较运算符

从程序员的角度来看, Shell本身是一种用C语言编写的程序,从用户的角度来看,Shell是用户与Linux操作系统沟通的桥梁。用户既可以输入命令执行,又可以利用 Shell脚本编程,完成更加复杂的操作。在Linux GUI日益完善的今天,在系统管理等领域,Shell编程仍然起着不可忽视的作用。深入地了解和熟练地掌握Shell编程,是每一个Linux用户的必修 功课之一。

Linux的Shell种类众多,常见的有:Bourne Shell(/usr/bin/sh或/bin/sh)、Bourne Again Shell(/bin/bash)、C Shell(/usr/bin/csh)、K Shell(/usr/bin/ksh)、Shell for Root(/sbin/sh),等等。不同的Shell语言的语法有所不同,所以不能交换使用。每种Shell都有其特色之处,基本上,掌握其中任何一种 就足够了。在本文中,我们关注的重点是Bash,也就是Bourne Again Shell,由于易用和免费,Bash在日常工作中被广泛使用;同时,Bash也是大多数Linux系统默认的Shell。在一般情况下,人们并不区分 Bourne Shell和Bourne Again Shell,所以,在下面的文字中,我们可以看到#!/bin/sh,它同样也可以改为#!/bin/bash。

来源:http://blog.csdn.net/sunboy_2050/article/details/6836382

运算符描述示例
文件比较运算符
-e filename如果 filename 存在,则为真[ -e /var/log/syslog ]
-d filename如果 filename 为目录,则为真[ -d /tmp/mydir ]
-f filename如果 filename 为常规文件,则为真[ -f /usr/bin/grep ]
-L filename如果 filename 为符号链接,则为真[ -L /usr/bin/grep ]
-r filename如果 filename 可读,则为真[ -r /var/log/syslog ]
-w filename如果 filename 可写,则为真[ -w /var/mytmp.txt ]
-x filename如果 filename 可执行,则为真[ -L /usr/bin/grep ]
filename1 -nt filename2如果 filename1 比 filename2 新,则为真[ /tmp/install/etc/services -nt /etc/services ]
filename1 -ot filename2如果 filename1 比 filename2 旧,则为真[ /boot/bzImage -ot arch/i386/boot/bzImage ]
字符串比较运算符 (请注意引号的使用,这是防止空格扰乱代码的好方法)
-z string如果 string 长度为零,则为真[ -z "$myvar" ]
-n string如果 string 长度非零,则为真[ -n "$myvar" ]
string1 = string2如果 string1 与 string2 相同,则为真[ "$myvar" = "one two three" ]
string1 != string2如果 string1 与 string2 不同,则为真[ "$myvar" != "one two three" ]
算术比较运算符
num1 -eq num2等于[ 3 -eq $mynum ]
num1 -ne num2不等于[ 3 -ne $mynum ]
num1 -lt num2小于[ 3 -lt $mynum ]
num1 -le num2小于或等于[ 3 -le $mynum ]
num1 -gt num2大于[ 3 -gt $mynum ]
num1 -ge num2大于或等于[ 3 -ge $mynum ]

算术运算符 
+ - * / % 表示加减乘除和取余运算
+= -= *= /= 同 C 语言中的含义
位操作符

> >>= 表示位左右移一位操作
& &= | |= 表示按位与、位或操作
~ ! 表示非操作
^ ^= 表示异或操作
关系运算符 

= == != 表示大于、小于、大于等于、小于等于、等于、不等于操作
&& || 逻辑与、逻辑或操作

测试命令test命令用于检查某个条件是否成立,它可以进行数值、字符和文件3个方面的测试,其测试符和相应的功能分别如下。

(1)数值测试:

-eq 等于则为真。

-ne 不等于则为真。

-gt 大于则为真。

-ge 大于等于则为真。

-lt 小于则为真。

-le 小于等于则为真。

(2)字串测试:

= 等于则为真。

!= 不相等则为真。

-z字串 字串长度伪则为真。

-n字串 字串长度不伪则为真。

(3)文件测试:

-e文件名 如果文件存在则为真。

-r文件名 如果文件存在且可读则为真。

-w文件名 如果文件存在且可写则为真。

-x文件名 如果文件存在且可执行则为真。

-s文件名 如果文件存在且至少有一个字符则为真。

-d文件名 如果文件存在且为目录则为真。

-f文件名 如果文件存在且为普通文件则为真。

-c文件名 如果文件存在且为字符型特殊文件则为真。

-b文件名 如果文件存在且为块特殊文件则为真

条件变量替换: 
Bash Shell可以进行变量的条件替换,既只有某种条件发生时才进行替换,替换
条件放在{}中.
(1) ${value:-word}
当变量未定义或者值为空时,返回值为word的内容,否则返回变量的值.

(2) ${value:=word}

与前者类似,只是若变量未定义或者值为空时,在返回word的值的同时将 word赋值给value(3) ${value:?message}

若变量已赋值的话,正常替换.否则将消息message送到标准错误输出(若此替换出现在Shell程序中,那么该程序将终止运行)(4) ${value:+word}

若变量已赋值的话,其值才用word替换,否则不进行任何替换

(5) ${value:offset}

${value:offset:length} 从变量中提取子串,这里offset和length可以是算术表达式.
(6) ${#value}

变量的字符个数

(7) ${value#pattern}

${value##pattern}
去掉value中与pattern相匹配的部分,条件是value的开头与pattern相匹配
#与##的区别在于一个是最短匹配模式,一个是最长匹配模式.
(8) ${value%pattern}

${value%%pattern}
于(7)类似,只是是从value的尾部于pattern相匹配,%与%%的区别与#与##一样
(9) ${value/pattern/string}

${value//pattern/string}
进行变量内容的替换,把与pattern匹配的部分替换为string的内容,/与//的区别与上同
注意: 上述条件变量替换中,除(2)外,其余均不影响变量本身的值

#!/bin/bash

var1="1"
var2="2"

下面是“”运算符-a,另外注意,用一个test命令就可以了,还有if条件后面的分号

if test $var1 = "1"-a $var2 = "2" ; then
echo "equal"
fi

下面是“”运算符 -o,有一个为真就可以

if test $var1 != "1" -o $var2 != "3" ; then
echo "not equal"
fi

下面是“”运算符
if条件是为真的时候执行,如果使用!运算符,那么原表达式必须为false

if ! test $var1 != "1"; then
echo "not 1"
fi
以上三个if都为真,所以三个echo都会打印

示例:

  1. #!/bin/sh
  2. aa="August 15, 2012"
  3. bb="August 15, 20122"
  4. cc="123"
  5. dd="123"
  6. # -o
  7. if [ "$aa" = "$bb" -o "$cc" = "$dd" ]; then
  8.     echo "yes"
  9. else
  10.     echo "no"
  11. fi
  12. # -a and !
  13. if [ "$aa" != "$bb" -a "$cc" = "$dd" ]; then
  14.     echo "yes"
  15. else
  16.     echo "no"
  17. fi

运行结果:

true------------------------------------------------------------------------------------------------------

shell字符串比较、判断是否为数字

二元比较操作符,比较变量或者比较数字.注意数字与字符串的区别.

1 整数比较

-eq       等于,如:if [ "$a" -eq "$b" ]

-ne       不等于,如:if [ "$a" -ne "$b" ]

-gt       大于,如:if [ "$a" -gt "$b" ]

-ge       大于等于,如:if [ "$a" -ge "$b" ]

-lt       小于,如:if [ "$a" -lt "$b" ]

-le       小于等于,如:if [ "$a" -le "$b" ]

<       小于(需要双括号),如:(("$a" < "$b"))

<=       小于等于(需要双括号),如:(("$a" <= "$b"))

>       大于(需要双括号),如:(("$a" > "$b"))

>=       大于等于(需要双括号),如:(("$a" >= "$b"))

整数比较实例

  1. #!/bin/bash
  2. file='folder_url_top24/url_usa_top24_0'
  3. fileSize=`ls -l folder_url_top24/url_usa_top24_0 | awk -F '[" "]' '{print $5}'`
  4. FILESIZE=1000
  5. #while [ ! -f $file -o "$fileSize" -lt "$FILESIZE" ]
  6. #while [ ! -f $file -o "$fileSize" -lt 1000 ]
  7. while (("$fileSize" < 1000))
  8. do
  9.     echo "down again..."
  10. done

其中,下面三种整数比较都成立:1) while [ ! -f $file -o "$fileSize" -lt "$FILESIZE" ]

2) while [ ! -f $file -o "$fileSize" -lt 1000 ]

3) (("$fileSize" < 1000))

推荐使用第一种

2 字符串比较
=       等于,如:if [ "$a" = "$b" ]

==       等于,如:if [ "$a" == "$b" ],与=等价
注意:==的功能在[[]]和[]中的行为是不同的,如下:
1 [[ $a == z* ]]    # 如果$a以"z"开头(模式匹配)那么将为true
2 [[ $a == "z*" ]] # 如果$a等于z*(字符匹配),那么结果为true
3
4 [ $a == z* ]      # File globbing 和word splitting将会发生
5 [ "$a" == "z*" ] # 如果$a等于z*(字符匹配),那么结果为true
一点解释,关于File globbing是一种关于文件的速记法,比如"*.c"就是,再如~也是.
但是file globbing并不是严格的正则表达式,虽然绝大多数情况下结构比较像.

!=       不等于,如:if [ "$a" != "$b" ]
这个操作符将在[[]]结构中使用模式匹配.

<       小于,在ASCII字母顺序下.如:
if [[ "$a" < "$b" ]]
if [ "$a" \< "$b" ]
注意:在[]结构中"<"需要被转义.

>       大于,在ASCII字母顺序下.如:
if [[ "$a" > "$b" ]]
if [ "$a" \> "$b" ]
注意:在[]结构中">"需要被转义.
具体参考Example 26-11来查看这个操作符应用的例子.

-z       字符串为"null".就是长度为0

-n       字符串不为"null"

判断shell传入的参数个数是否为空:

  1. #!/bin/bash
  2. port=6379       # 命令行没参数,默认指定端口号为 6379
  3. if [ $# -ge 1 ]; then   # 命令行参数个数大于等于1,则使用传入的参数port
  4.     port=$1     # 获取指定端口号
  5. fi
  6. echo "redis port: $port"
  7. redis-cli -h 172.1628.10.114 -p $port

字符串比较实例:

if [ "$var1" = "$var2" ]

代码:

  1. #!/bin/sh
  2. aa="August 15, 2012"
  3. bb="August 15, 2012"
  4. if [ "$aa" = "$bb" ]; then
  5.     echo "yes"
  6. else
  7.     echo "no"
  8. fi

判断子字符串包含关系: =~

代码:

  1. a1="ithomer"
  2. a2="ithomer.net"
  3. a3="blog.ithomer.net"
  4. if [[ "$a3" =~ "$a1" ]]; then
  5.          echo "$a1是$a3的子串!"
  6. else
  7.          echo "$a1不是$a3的子串!"
  8. fi
  9. if [[ "$a3" =~ "$a2" ]];then
  10.          echo "$a2是$a3的子串!"
  11. else
  12.          echo "$a2不是$a3的子串!"
  13. fi

注意:
使用-n在[]结构中测试必须要用""把变量引起来.使用一个未被""的字符串来使用! -z或者就是未用""引用的字符串本身,放到[]结构中。虽然一般情况下可以工作,但这是不安全的.习惯于使用""来测试字符串是一种好习惯.

awk '{print $2}' class.txt | grep '^[0-9.]' > res