your embarrassing, our passion!

其实没什么, 对于这一个无聊的工作一点也不可惜. 没意思….

快两年了, 只会用一些肤浅的东西, 只能听懂简单的日语, 留着何用

考研, 没有退路, 只能考上了…..每天15个小时, 8个月, 4门课…

再考不上足以证明我是白痴

HttpSession session = (HttpSession)FacesContext.getCurrentInstance().getExternalContext().getSession(true);

session.setAttribute(sessionName,sessionValue);

2.获取session值

String getName = session.getAttribute(“name”).toString();

3.清除session

session.invalidate();

1.如在你的页面中有
注意要写在form中,并且要用name而不是id.
FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get( “classid “)可以得到。

2.

FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get( “f:classid “)可以得到。

3.使用JSF自带的控件，则和2是一样的访问方法

以上方法就可以了，写id的时候，jsf会把form的id加进去 变成 formId:componentId 的格式

第二种：

就是通过findComponent方法获得控件实例，然后通过getValue方法获得值
HtmlInputText text = (HtmlInputText) this.findComponent(this.FORM + “:”+ ENERGY_COMSUPTION_PREFIX + id);
String value = text.getValue().toString();

public UIComponent findComponent(String name) {

// 不能使用静态变量view保持当前的viewroot，因为每次操作之后的viewroot都是不一样的
ViewRoot view = FacesContext.getCurrentInstance().getViewRoot();

return view.findComponent(name);
}

需要注意的是 不能使用静态变量view保持当前的viewroot，因为每次操作之后的viewroot都是不一样的。

对比以上两种方法，第一种简单方便，但只适合于取值操作。第二种可操控的范围和能力更大，不仅可以取值还可以设置和获得所有属性。

这里用 hibernate 作为 JPA(java persistent API), dojo的 Ajax 标签.

Prerequisites

首先得先下个IDE 和 Application Server 和 database

• Eclipse Ganymede for JEE
• Tomcat6
• MySQL Server

开发环境准备好以后我们来建工程

MySql

先建数据库和表……..

Code

源代码到 GoogleCode 的 这里 目录下的 /struts2_spring_hibernate/quickStart 下到, 可以先下下来看看, 或者直接按下面的自己从头做

Just Do It

用eclipse 建立工程

选择 动态web

选tomcat 6 , project 命名 为 quickstart

于是得到上图目录, 在 lib里加上所有需要的 jar 包

这些 jar 包然人的很….动不动缺这动不动缺那, 如果出现莫名奇妙的错误说那个 class not found 的话,

可以把找不到的 class 贴到 这里 找缺少的是哪个包.

• 到 Struts 2 下 2.1.6 版本
• 到 MySql JDBC Driver 下 mysql 的 驱动
• 到 Spring 2 下 spring2.5.6
• 到 Hibernate 下 Hibernate Core, Hibernate Annotations, Hibernate Entity Manager
• 下 log4j

把这些下下来的 jar 包都考到上图的 lib 目录下

起码我的 lib 里面 有这些文件

antlr-2.7.6.jar
commons-collections-3.1.jar
commons-fileupload-1.2.1.jar
commons-io-1.3.2.jar
commons-logging-1.1.jar
dom4j-1.6.1.jar
ehcache-1.2.3.jar
ejb3-persistence.jar
freemarker-2.3.13.jar
hibernate3.jar
hibernate-annotations.jar
hibernate-cglib-repack-2.1_3.jar
hibernate-commons-annotations.jar
hibernate-entitymanager.jar
javassist-3.4.GA.jar
json-lib-2.1.jar
jta-1.1.jar
junit-3.8.1.jar
log4j-1.2.15.jar
mysql-connector-java-5.0.8-bin.jar
ognl-2.6.11.jar
slf4j-api-1.5.6.jar
slf4j-log4j12-1.5.6.jar
slf4j-simple-1.5.6.jar
spring.jar
spring-aop.jar
spring-beans.jar
spring-context.jar
spring-context-support.jar
spring-core.jar
spring-jdbc.jar
spring-jms.jar
spring-orm.jar
spring-test.jar
spring-test-2.5.6.jar
spring-tx.jar
spring-web.jar
spring-webmvc.jar
spring-webmvc-portlet.jar
spring-webmvc-struts.jar
struts2-core-2.1.6.jar
struts2-dojo-plugin-2.1.6.jar
struts2-spring-plugin-2.1.6.jar
xwork-2.1.2.jar

注意 struts2-dojo-plugin-2.1.6.jar 一定要考进来,  Struts 2.1 把 dojo 标签给剔除了, 我配的时候可玩死我了. Struts 2.0 是整合的.

具体 看 这里 struts2.0 到 struts2.1 的变化

Model

model 很简单, 就单单一个 bean, 一个表

package quickstart.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Person {
    @Id
    @GeneratedValue
    private Integer id;
    private String lastName;
    private String firstName;

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }
}

一个Person表, 属性有 id, lastName, firstName 其中 id 为 key

我们用到了 @Entity , 用这个 annotations 声明了这个class可以被持久化(persisted)

@Id 声明 id 是key

@GeneratedValue : hibernate 会生成属性 Value

DAO

一个 Dao 的接口

package quickstart.service;

import java.util.List;

import quickstart.model.Person;

public interface PersonService {
    public List<Person> findAll();

    public void save(Person person);

    public void remove(int id);

    public Person find(int id);
}

实现

package quickstart.service;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.springframework.transaction.annotation.Transactional;

import quickstart.model.Person;

@Transactional
public class PersonServiceImpl implements PersonService {
    private EntityManager em;

    @PersistenceContext
    public void setEntityManager(EntityManager em) {
        this.em = em;
    }

    @SuppressWarnings("unchecked")
    public List<Person> findAll() {
        Query query = getEntityManager().createQuery("select p FROM Person p");
        return query.getResultList();
    }

    public void save(Person person) {
        if (person.getId() == null) {
            // new
            em.persist(person);
        } else {
            // update
            em.merge(person);
        }
    }

    public void remove(int id) {
        Person person = find(id);
        if (person != null) {
            em.remove(person);
        }
    }

    private EntityManager getEntityManager() {
        return em;
    }

    public Person find(int id) {
        return em.find(Person.class, id);
    }

}

Spring 见到 @PersistenceContex 的注释会 注入 EntityManager 到这个实例.

而 @Transactional 的声明, Spring 会让这些方法都运行在一个 transaction 中.

配置 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="person" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <display-name>person</display-name>

    <!-- Include this if you are using Hibernate -->
    <filter>
        <filter-name>Spring OpenEntityManagerInViewFilter</filter-name>
        <filter-class>
            org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter
        </filter-class>
    </filter>

    <filter-mapping>
        <filter-name>Spring OpenEntityManagerInViewFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>
            org.apache.struts2.dispatcher.FilterDispatcher
        </filter-class>
    </filter>

    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
</web-app>

所有 requests 将被 redirect 到 Struts 的 “FilterDispatcher” class, Spring’s “ContextLoaderListener” 监听

配置 Spring

在WEB-INF 地下 建立 applicationContext.xml 来配置 Sping

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

    <bean
        class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />

    <bean id="personService" class="quickstart.service.PersonServiceImpl" />

    <bean id="entityManagerFactory"
        class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="jpaVendorAdapter">
            <bean
                class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="database" value="MYSQL" />
                <property name="showSql" value="true" />
            </bean>
        </property>
    </bean>

    <bean id="dataSource"
        class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost/quickstart" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>

    <bean id="transactionManager"
        class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>

    <tx:annotation-driven transaction-manager="transactionManager" />

    <bean id="personAction" scope="prototype"
        class="quickstart.action.PersonAction">
        <constructor-arg ref="personService" />
    </bean>
</beans>

注意 Spring 的依赖注入(Dependency Inject, 以后简称 DI), “personAction” bean 构造函数的参数设置为 “personService” bean, 为什么这样传我们后面介绍

而 scope 属性是 Spring2 新加的,  设成 “prototype” 表示每次请求实例化一个新的 Action.

“dataSource” bean 连接数据库

配置 Struts

首先新建一个 Action, Struts2 已经把 ActionBean和 Action 整合到了一起.

package quickstart.action;

import java.util.List;

import quickstart.model.Person;
import quickstart.service.PersonService;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.Preparable;

public class PersonAction implements Preparable {
    private PersonService service;
    private List<Person> persons;
    private Person person;
    private Integer id;

    public PersonAction(PersonService service) {
        this.service = service;
    }

    public String execute() {
        this.persons = service.findAll();
        return Action.SUCCESS;
    }

    public String save() {
        this.service.save(person);
        this.person = new Person();
        return execute();
    }

    public String remove() {
        service.remove(id);
        return execute();
    }

    public List<Person> getPersons() {
        return persons;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void prepare() throws Exception {
        if (id != null)
            person = service.find(id);
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}

这就是一个简单的 POJO (Plain Old Java Object) 了, 也就是一个简单的bean, 没有Entity.

构造函数的参数 service 就是由 Spring 配过来的了.

然后来配置跳转, 这里 struts-config.xml 应该是扔到 src 目录下, 与 Struts1不一样.

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <constant name="struts.objectFactory" value="spring" />

    <package name="person" extends="struts-default">

        <action name="list" method="execute" class="personAction">
            <result>pages/list.jsp</result>
            <result name="input">pages/list.jsp</result>
        </action>

        <action name="remove" class="personAction" method="remove">
            <result>pages/list.jsp</result>
            <result name="input">pages/list.jsp</result>
        </action>

        <action name="save" class="personAction" method="save">
            <result>pages/list.jsp</result>
            <result name="input">pages/list.jsp</result>
        </action>
    </package>
</struts>

其中 “struts.objectFactory” 的配置很重要, 他让 Spring 来为他构造 Object, 这里面的 class=的 就是刚刚 Spring 配好的 bean 了.

Pages

下面该做页面了, 首先是一个 输出 页面

注意, Struts2.1 没有整合 dojo 的标签, 所以这里还必须另外用 dojo 的标签. 另外, Struts2.0 是整合 dojo 标签的, 具体看 这里

<%@ taglib prefix="s" uri="/struts-tags"%>
<%@ taglib prefix="sx" uri="/struts-dojo-tags"%>
<p>Persons</p>
<s:if test="persons.size > 0">
    <table>
        <s:iterator value="persons">
            <tr id="row_<s:property value="id"/>">
                <td>
                    <s:property value="firstName" />
                </td>
                <td>
                    <s:property value="lastName" />
                </td>
                <td>
                    <s:url id="removeUrl" action="remove">
                        <s:param name="id" value="id" />
                    </s:url>
                    <sx:a href="%{#removeUrl}"targets="persons">Remove</sx:a>
                    <sx:a id="a_%{#id}" notifyTopics="/edit">Edit</sx:a>
                </td>
            </tr>
        </s:iterator>
    </table>
</s:if>

每行数据 一个姓一个名, 一个 remove 链接, 一个 Edit 链接

<%@ taglib prefix="s" uri="/struts-tags"%>
<%@ taglib prefix="sx" uri="/struts-dojo-tags" %>
<html>
    <head>
        <sx:head parseContent="true"/>
        <script type="text/javascript">
            dojo.event.topic.subscribe("/save", function(data, type, request) {
                if(type == "load") {
                    dojo.byId("id").value = "";
                    dojo.byId("firstName").value = "";
                    dojo.byId("lastName").value = "";
                }
            });

            dojo.event.topic.subscribe("/edit", function(data, type, request) {
                if(type == "before") {
                    var id = data.split("_")[1];

                    var tr = dojo.byId("row_"+id);
                    var tds = tr.getElementsByTagName("td");

                    dojo.byId("id").value = id;
                    dojo.byId("firstName").value = dojo.string.trim(dojo.dom.textContent(tds[0]));
                    dojo.byId("lastName").value = dojo.string.trim(dojo.dom.textContent(tds[1]));
                }
            });
        </script>
    </head>
    <body>
        <s:url action="list" id="descrsUrl"/>

        <div style="width: 300px;border-style: solid">
            <div style="text-align: right;">
                <sx:a notifyTopics="/refresh">Refresh</sx:a>
            </div>
            <sx:div id="persons"  href="%{#descrsUrl}" loadingText="Loading..." listenTopics="/refresh"/>
        </div>

        <br/>

        <div style="width: 300px;border-style: solid">
            <p>Person Data</p>
            <s:form action="save" validate="true">
                <s:textfield id="id" name="person.id" cssStyle="display:none"/>
                <s:textfield id="firstName" label="Fisrt Name" name="person.firstName"/>
                <s:textfield id="lastName" label="Last Name" name="person.lastName"/>
                <sx:submit targets="persons" notifyTopics="/save"/>
            </s:form>
        </div>
    </body>
</html>

这是 index.jsp 填入 firstName 和 lastName 点 submit 保存

Run

现在我们来跑一下程序

把application server 配好

这里用的是tomcat6, 如果你用的服务器这里没有, 可以点 右上角的 “Download additional server adapter”

比如说 glassfish, 或者websphere communication edition

发布工程

底下的勾勾勾上, 可以及时发布.

启动服务器, 有 debug 和 run 模式

访问 http://localhost:8080/quickstart/

就可以看见页面了

Reference

Struts 2 + Spring 2 + JPA + AJAX

Troubleshooting guide migrating from Struts 2.0.x to 2.1.x

Spring 当然要从他最出名的 依赖注入(Dependency injection) 讲起了, 但是现在先举个 Hello World 的例子

public interface GreetingService {
void sayGreeting();
}

先建一个bean的接口

public class GreetingServiceImpl implements GreetingService {
  private String greeting;
  public GreetingServiceImpl() {}
  public GreetingServiceImpl(String greeting) {
    this.greeting = greeting;
  }
  public void sayGreeting() {
    System.out.println(greeting);
  }
  public void setGreeting(String greeting) {
    this.greeting = greeting;
  }
}

实现他.

可以看得出来, 构造函数和 set 方法都可以给属性 greeting 赋值

现在, 配置 spring 容器来给这个bean 的 greeting 属性赋值

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
  <bean id="greetingService"
      class="com.springinaction.chapter01.hello.GreetingServiceImpl">
    <property name="greeting" value="Buenos Dias!" />
  </bean>
</beans> 

让我们来看这个 xml, 简单的结果, 告诉 spring 容器给 beans 底下的名叫 greetingService 的 Bean 的 greeting 属性 的value 设成 “Buenos Dias”
容器会自动实例出 GreetingServiceImpl并调用其 set 方法…
此段xml 将会被容器翻译成

GreetingServiceImpl greetingService = new GreetingServiceImpl();
greetingService.setGreeting("Buenos Dias!"); 

我们还可以直接用构造函数 给属性赋值

<bean id="greetingService"
    class="com.springinaction.chapter01.hello.GreetingServiceImpl">
  <constructor-arg value="Buenos Dias!" />
</bean> 

下面来看 注入 进去的属性怎么取

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;
public class HelloApp {
  public static void main(String[] args) throws Exception {
    BeanFactory factory =
        new XmlBeanFactory(new FileSystemResource("hello.xml"));
    GreetingService greetingService =
        (GreetingService) factory.getBean("greetingService");
    greetingService.sayGreeting();
  }
}

不直接实例化 bean 而从容器中取……

到这里已经可以很好的理解 spring 容器的 注入(inject), 那 依赖(dependency)呢?

Ajax in Action, 好厚一本书, 大学写论文的时候当参考资料翻译看了一点, 现在继续, 笔记一下, less i forget

1 JavaScript: The central player

An Ajax application downloads a complete client into memory, combining data and presentation
and program logic, and JavaScript is the tool used to implement that logic.

• Loosely typed: 不指定类型
• Interpreted: 中间语言
• General purpose: 适用算法和编程

2 CSS(Cascading Style Sheets) 级联样式单

2.1 CSS selectors

2.1.1 element-based selectors

选择html tag 应用CSS

div h1 { color: red; }

将对<div>中所有<H1>适用

2.1.2 additional style class

.callout { border: solid blue 1px; background-color: cyan }

需要在 tag 中指定

<div>I’ll appear as a normal bit of text</div>
<div class=’callout’>And I’ll appear as a callout!</div>

而且还可以在 tag 中加多个 style class

<div class=’callout loud’>
And I’ll appear as an unappealing mixture of both!
</div>

2.1.3 combine classes with element-based rules

还可以绑定style class 到指定标签

span.highlight { background-color: yellow }

只有声明 highlight 的 span 标签才适用这个样式

再复杂点

div.prose span.highlight { background-color: yellow }

只选择

<div class=”prose “>
<span class=”highlight” ………/>
</div class=”prose “>

中span中的内容适用式样

2.1.4 apply only to an element with a given unique ID

按 ID 选择

#close { color: red }

只选择 id=”close” 的 tag

2.1.5 pseudo-selectors

浏览器定义了一些 pseudo-selectors
如

*:first-letter {
font-size: 500%;
color: red;
float: left;
}

会把所有 element 的头字母 弄成更大而且是红色

而CSS可以基于这个 pseudo-selectors 自定义样式单

p.illuminated:first-letter {
font-size: 500%;
color: red;
float: left;
}

现在这个样式会只适用到 声明过class=”illuminated” 的 <p> 标签

其他还有一些有用的 pseudo-selectors,如first-line, hover
hove 会作用于鼠标下超链接

a:hover{ color:yellow; }

就会使所鼠标下的 <a> 标签变黄

2.2 CSS style properties

属性, 每个 tag 上都可以适用很多属性, 先来看这几个

.robotic{
font-size: 14pt;
font-family: courier new, courier, monospace;
font-weight: bold;
color: gray;
}

指定字体 font 和 color, 可以写的更简单点

.robotic{
font: bold 14pt courier new, courier, monospace;
color: gray;
}

我们来举个例子看怎样使用 CSS.

2.3 A simple CSS example

首先来看一下用完 CSS 的效果, 使用 CSS 完成类似 windows explorer 的效果的widget.

现在开始分析, 从哪下手

Using CSS for layout

当然一眼过去可以分成2个部分, window, items

div.window{
position: absolute;
overflow: auto;
margin: 8px;
padding: 0px;
width: 420px;
height: 280px;
}

div.item{
position: relative;
height: 64px;
width: 56px;
float: left;
padding: 0px;
margin: 8px;
}

然后, 每个items都还有个items名

div.item div.itemName{
margin-top: 48px;
font: 10px verdana, arial, helvetica;
text-align: center;
}

当然不同种类的items还有不同的图标

div.folder{
background:
transparent url(images/folder.png)
top left no-repeat;
}
div.file{
background:
transparent url(images/file.png)
top left no-repeat;
}
div.special{
background:
transparent url(images/folder_important.png)
top left no-repeat;
}

差点把标题栏忘了

div.titlebar{
background-color: #0066aa;
background-image: url(images/titlebar_bg.png);
background-repeat: repeat-x;
…
}

1. 转义

\a 警告
[\b] 回车
\e   Esc
\f    formfeed 换页
\n 换行
\r 回车
\t 横向tab
\v 纵向tab
\O## 两位十进制数
\x## 两位十六进制数
\u#### 四位十六进制数
\cchar control characters ctrl+char??

2. Character Classes and Class-Like Constructs  匹配字符集

[] [^] 单字符集合
. 除了换行以外的任何字符
\w 所有unicode字符, [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}] , 在纯ASCII模式中可以表示为 [a-zA-Z_0-9]
\W    \w的非
\d 数字, \p{Nd}, 在纯ASCII模式中可以表示为 [0-9]
\D    \d的非
\s     Whitespace character空白字符, [ \f\n\r\t\v\x85\p{Z}], 在纯ASCII模式中可以表示为[ \f\n\r\t\v]
\S    \s的非
\p Unicode properties and block
\P    \p的非

3. Anchors and Other Zero-Width Tests 匹配位置

^ \A     行头
$ \z \Z  行尾
\G         前次匹配的末尾 End of previous match
\b \B     单词界

(?= ⋯) Lookahead 返回true 如果匹配当前位置之后

(?! ⋯) Lookahead 返回true 如果不匹配当前位置之后

(?<=⋯) Lookbehind 返回true 如果匹配当前位置之前

(?<!⋯) Lookbehind 返回true 如果不匹配当前位置之前

4. Comments and Mode Modifiers  匹配模式

(?modifier)(?-modifier)       支持 x s m i n ,如 (?i)…(?-i) 将以忽略大小写模式匹配
(?modifier:…..) 只是另一种写法,如 (?i:….) 将以忽略大小写模式匹配
(?#….)             注释

5. Grouping, Capturing, Conditional, and Control  分组匹配

(…)\1\2                           分组/捕获
(?:…) 只分组, 不被捕获
(?<name-name>….)        按名字捕获
(?<name>…)  \k<name> 按名字分组捕获
(?>…)                            Atomic grouping 只要匹配成功就不走组内剩余分支
|                                    Alternation  或
* + ? {n} {n,} {x,y} Greedy quantifiers
*? +? ?? {n}? {n,}? {x,y}?  Lazy quantifiers
(?if then|else)                  Conditional

6. Regex Modes

.Singleline                           单行模式, 点可以匹配任何字符, 等于(?s)
.Mutiline                             多行模式, ^和$有效, 等于(?m)
.IgnorePatternWhitespace    忽略空格的注释模式, 等于(?x)
.IgnoreCase                        忽略大小写, 等于(?i)
.ExplicitCapture                  精确捕获, 只捕获(?<name>…..), 等于(?n)
.ECMAScript                      只匹配ASCII字符
.RightToLeft                        从右忘左匹配
.Compiled                           编译正则, 使得运行时更快

以上涵盖了几乎所有.NET所支持的正则表达式, 下面介绍如何在C#中使用

Quickstart

在C#中, 用Regex, Match, Groups 这3个对象就可以实现正则表达式了, 下面来看一个简单的例子

用正则表达式匹配一个日期, 然后分别输出所匹配出来的年, 月, 日

这段代码可以用SVN在
https://dotnetregularexpression.googlecode.com/svn/trunk/ dotnetregularexpression/regex/MatchAndCaptureGroup
下到, 当然也可以直接在 GoogleCode 看代码

 1 using System.Text.RegularExpressions;
 2     class MatchTest
 3     {
 4         static void Main()
 5         {
 6             string date = "12/30/1969";
 7             //定义Regx
 8             Regex r =
 9               new Regex(@"^(\d\d)[-/](\d\d)[-/](\d\d(?:\d\d)?)$");
10             //定义Match
11             Match m = r.Match(date);
12             System.Console.Out.WriteLine("In US prefer: " + m.ToString());
13 
14             if (m.Success)
15             {
16                 //使用Group
17                 string month = m.Groups[1].Value;
18                 string day = m.Groups[2].Value;
19                 string year = m.Groups[3].Value;
20                 System.Console.Out.Write("month: " + month + "\n" + "day: " + day + "\n" + "year: " + year + "\n");
21                 //使用Regex.Replace
22                 System.Console.Out.Write("In Chinese prefer: " + r.Replace(date, "$3年$1月$2日"));
23                 //使用Match.Replace
24                 System.Console.Out.Write("In Japanese prefer: " + m.Result("$3/$1/$2"));
25                 Console.ReadLine();
26             }
27         }
28     }

6行: 声明一个讲被匹配的对象日期 12/30/1969

8行: Regex
@”…..”可以防止双引号中的字符转义
这个正则很简单, 其中的(?:\d\d) 表示这两个\d不会被Group到, 这个后面会讲到

11行: Match
用Regex匹配日期, 返回一个Match型的对象
MatchObject.Success() 返回匹配结果
MatchObject.ToString() 将返回匹配上的字符
MatchObject.Groups() 返回所匹配的Group对象数组

12行: Group
用GroupObject.Value() 可以取出被group匹配的值

22行: 置换
RegexObject.Replace(text, replacement) 可以把text中匹配部分置换成replacement
其中的$1, $2, $3 要解释一下,
在C#中, Regex.Replace 和 Match.Result(24行) 都支持用’$'符号转义, 讲一下常用的
$&  $0          代表所有被匹配的字符
$1,$2,…       代表被捕捉的group
${name}        按name捕捉上的group
$$                一个$
$_                被匹配前的整条字符串

Common Use

2. Lookaround

比如一长串金钱 549484656132 看起来很难分出来到底是多少钱…..要是能换成 549,484,656,132 就好多了,
一下就能读出来, 549 billion 484 million 656 thousand
如何加逗号?
用前面学过的可以想到, 分组匹配, 然后除了第一组其他都在前面加逗号
可以用 \b(\d{1,3})(\d\d\d)+\b 然后循环Group数组往中间加逗号, 这样可以吗?

调试会发现不行, 而且会发现group[1] 是549, 但是group[2]却是132, 只有两个group
这样加出来 只会是 549484656,132 怎么办?

现在插播 Lookaround

(?= ⋯) Lookahead 返回true 如果匹配当前位置之后

(?! ⋯) Lookahead 返回true 如果不匹配当前位置之后

(?<=⋯) Lookbehind 返回true 如果匹配当前位置之前

(?<!⋯) Lookbehind 返回true 如果不匹配当前位置之前

举个例子

(?<!\w)(?=\w)

代表什么? 其中 \w 代表有效Unicode字符, ASCII模式下相当于[a-zA-Z_0-9]

注意: Lookaround匹配的是位置

意思是当前位置之前没有字符, 当前位置之后有, 相当于单词界左边的 \b

那么 (?<!\w)(?=\w)|(?<=\w)(?!\w) 就完全等价于 \b 了

有了这个, 我们就能匹配出逗号的位置了, 现在回来看逗号怎么解决

很简单, 只要前面有数字, 后面有N组3位数, 这个位置就是逗号的位置

(?<=\d)(?=(?:\d\d\d)+\b)

22                 System.Console.Out.Write("In Chinese prefer: " + r.Replace(date, "$3年$1月$2日"));

然后按QuickStart中的这个置换功能, 将匹配上的位置都换成逗号

虽然.NET支持Lookbehind, 但是有些工具不支持Lookbehind, 怎么办?

\d(?=(?:\d\d\d)+\b)

**要是连 Lookahead都没有呢? 就实现不了了吗?

1. Grouping

1.1 Capturing/Grouping

可能大家还记得在 基本 里提到的Backreferences \1 \2 ….
\1 \2 可以回调到上次匹配上的字符, \1是第一个括号匹配上的, \2是第二个括号匹配上的
而这个用法是用在正则表达式里的, 要是我在程序里想取出来呢?
所以这样就引出了$1 $2 ….的用法, 上一节quick start 里已经稍微提到了一下
所有PCRE和类perl的引擎都支持 $1 $2…..

跟\1 \2 一样, 但是 $1 $2 可以在程序里直接调到被匹配上的Group, 见 QuickStart 22行 24行
至于Group其实很简单, 就是只要被括号括起来就叫一个Group
C# 中两种方法捕捉Group

17                 string month = m.Groups[1].Value;

24                 System.Console.Out.Write("In Japanese prefer: " + m.Result("$3/$1/$2"));

置换也可以用Group

22                 System.Console.Out.Write("In Chinese prefer: " + r.Replace(date, "$3年$1月$2日"));

1.2 Grouping-only parentheses

那要是嵌套括号怎么办? 如 QuickStart里的 ^(\d\d)[-/](\d\d)[-/](\d\d(?:\d\d)?)$ 中的下划线部分应该算 \几?
很简单, 不管嵌不嵌套, 只数左括号就可以了
那捕捉下划线部分就是 $4 ?

不是, 如果调试会发现 $4 不存在, 为什么
而这里出现的(?:\d\d) 在QuickStart中提了一下, (?:….)将不会被捕获, 他只是为了划分后面问号的作用域
其实加不加 ?: 结果不会有区别, 但是效率上来讲尽量只捕获一些你想要的Group
(?:…) 就可以实现这种一定要加括号, 但是不想被捕获的情况

1.3 Named capture

要是括号太多很难数的过来, 会浪费很多时间而且不明了

在.NET框架中支持按名字捕获, Python 和 PHP 的 preg 引擎都支持这种捕获
.NET中用 (?<name>…) 来按名字分组,  Backreferences  \k<name>
如果在程序里想使用按名字捕获到的组, 可以用 RegexObj.Groups["name"]
于是, 我的的QuickStart例可以改写成

 7             //定义Regx
 8             Regex r =
 9               new Regex(@"^(?<month>\d\d)[-/](?<day>\d\d)[-/](?<year>\d\d(?:\d\d)?)$");

16                 //使用Group
17                 string month = m.Groups["month"].Value;
18                 string day = m.Groups["day"].Value;
19                 string year = m.Groups["year"].Value;

会比较直观

1.4 Atomic grouping

原子group…..   (?>…)
只要失败就不走其他分支

我们知道 .*! 可以匹配 what’s up!
要是 (?>.*)! 呢?

<插播>
这里要注意星号, 他比较瓜,  只要匹配成功, 读到星号会继续用星号前的表达式继续匹配
于是光一个 .* 已经匹配上整个单词 包括叹号
然后继续读下一个表达式…居然是叹号, 于是引擎会回溯刚刚匹配的过程, 用叹号再来一次
这样听起来效率就很低, 如果我后面有一千个问号号, 而我只想要前面的what’s up!
.* 就白白多匹配了999个问号, 要优化很简单, 只要遇到叹号就失败就可以了  [^!]*!
但是如果我要匹配 up 前面的怎么办? [^up]*up 可以吗? no

<插播>
我们把 * 叫做Greedy quantifiers 贪婪计量号
与贪婪相反的是懒惰, 于是.NET还支持 懒惰计量号 Lazy quantifiers, 就是在贪婪符号后加问号
如 <tag>.*?</tag>
刚好跟贪婪相反, 他会一直看 ? 后面的字符是否匹配上, 只要匹配就跳出星号的贪婪匹配
拿刚刚的表达式来匹配 <tag>here’s a <tag></tag>
当走完 第一个<tag> 引擎先会先匹配 ? 后面的字符, 如果是 </tag> 就直接不走问号前面的 .* 了
如果不是, 继续用 . 匹配,
</插播>
再回到要匹配 up 前面的问题, 用懒惰匹配可以写成   .*?up
</插播>

说回来刚刚叹号的问题 atomic grouping 不保留匹配过的状态, 也就是说正则引擎不会回溯过去的状态看有没有叹号
所以 (?>.*)! 匹配 what! 不会成功
这个例子好像看不出来 atomic grouping 有什么好处, 效率一样嘛
但是如果用来匹配 what 呢? 没有叹号.
如果用 (?>.*)! 当走到叹号的时候直接就失败了
而用 .*! 还会回溯循环找叹号

所以 atomic grouping 的效率就体现在匹配不成功的时候

(?>.*?) 匹配什么?

1.5 IF ELSE

(?if then|else)
这里说下用什么当if条件
1. 用 lookaround
(?(?<=num)\d|\w)  如果当前位置前面是num, 就用数字匹配
2. 用 reference
(num)(?(1)\d*|\w*)  如果以num 开头, 就用数字匹配

3. Mode modify

模式转换 (?modifier:….) 支持的模式有

x 单行模式, 点可以匹配任何字符
s 多行模式, ^和$有效
m 忽略空格的注释模式
i 忽略大小写
n 精确捕获, 只捕获(?<name>…..)

如: w(?i:hat) 相当于 w[Hh][Aa][Tt]

还有另外一种写法:   w(?i)hat(?-i)

4. 注释

只要在参数里加 RegexOptions.IgnorePatternWhitespace 就可以了, 变成忽略空格的注释模式, 注释用 # 号
于是我们的 QuickStart 例子里可以加注释了

 7             //定义Regx
 8             Regex r =
 9               new Regex(@"^(?<month>\d\d)[-/]   #this get the month
                           (?<day>\d\d)[-/]        #and this get the day
                           (?<year>\d\d(?:\d\d)?)$ #and this get the year"
                           , RegexOptions.IgnorePatternWhitespace);

这里先总结正则表达的一些基础, 部分专业术语不会翻译，就直接用英文了

参考数目可以到这里下载

首先介绍一下正则表达式WIKI

ed        Unix的文本编辑器, 最早引入正则表达式搜索的编辑器

grep     最早使用正则表达式的搜索工具, 其实就是把ed的搜索功能抽出来, 叫grep是因为g/re/p是ed使用正则表达式搜索时使用的命令

Egrep  随后出生于AT&T Bell Labs, 在grep基础上加了n多功能

POSIX  (Portable Operating System Interface for Unix)  为跨平台的正则表达式提供标准API, 一些传统工具用到这个标准, 但是在这里不提及了, 基本不会用到他

Perl      比POSIX更强大更灵活,大多高级程序设计语言中都使用类似语法, 如 Java, JavaScript, PCRE, Python, Ruby, Microsoft‘s .NET Framework. 其中PCRE(Perl Compatible Regular Expressions)是仿Perl的API, 而PHP 同时支持POSIX和PCRE

在windows下我们可以用UE的正则表达式引擎, 比较容易用, 完成简单的搜索和替换

在UE ->Advanced->Configuration->Search->Regular Expressions Engine中勾选Perl compatible Regular Expressions(PCRE)

因为perl对正则表达式支持的很全, 而且高级程序设计语言都跟perl的正则没有太大区别, 所以这里选择PCRE

这里再介绍两个可以在线测试正则表达式的网站

rexV                   支持Javascript, PCRE(PHP Preg), POSIX(PHP Ereg) , 这个支持的比较好, 而且表现方式我喜欢, 就是好像有点慢

REGex TESTER  支持Javascript, PCRE(PHP Preg), POSIX(PHP Ereg), 不知道为啥有些应该支持的表达式不支持, 这上面还有一些参考, 和一些常用的例子, 可以看看

regexlib               正则表达式库, 可以搜索你想要的正则表达式, 上面也有 .NET引擎的正则测试

*前两个AJAX网站, 建议用较好支持javasript的浏览器(貌似现在最快的是safari4)….不然计算会很慢

下面所有例子都刻在UE或者以上两个网上调试

*为了便于识别, 下面用 • 代表空格

1. Start and End of the Line

^: 开始符号
$ : 结束符号
由此
^cat$ :  只匹配 cat, 而且cat占一整行
^$： 匹配一行空行
 
 ^和$匹配的是位置, 而不是字符, ^代表这个位置是行头, $代表这个位置是行尾
  所以要匹配以cat開頭，以dog結束？如 “cat run after dog”
  可以用^cat.*dog$, 但是这样的话”catalog of dog”也同样会被匹配上
  所以要匹配以cat单词開頭，以dog单词結束, 需要用到第七节的知识

2. Character Classes

用[]中的集合来匹配
其实就是最经常见到的 [0-9a-zA-Z]
等价于[0123456789abcdefghijklmnopqrstuvwxyzABCDE...............], 匹配所有数字和字母。

3. Negated character classes

[^......]
字面翻译是‘非’, 这里用的符号还是^, 但是是在[]里用, 就算非的意思了
q[^u]: 匹配’q'后紧跟一个character, 但不能是’u’
如
    miqra
    qasida
    zaqqum%
但是
    Qantas

    Iraq
都不行
 
想想如果匹配不包含后缀”.txt”  用 .*\.[^txt]行不行, .*\.[^t][^x][^t] 呢?

4. Dot

点
.:匹配任何字符
03.19.76 匹配03[任何字符]19[任何字符]76

5. Alternation

|:或
gr[ea]y = grey|gray = gr(e|a)y
这里用括号把 | 的作用域定限定在 e|a , 如果不加括号就是 gre 或 ay
^From|Subject|Date 匹配^From 或 Subject 或 Date
^(From|Subject|Date) 匹配^From 或 ^Subject 或 ^Date

6. Ignoring Differences in Capitalization

忽略大小写, 加参数i (ignore)
egrep -i ‘from’  将匹配[Ff][Rr][Oo][Mm]
egrep 命令行是这么加 i 参数
而在UE中直接不勾Match Case就可以
用 rexV  和  REGex TESTER 勾选 i 就可以了
在C#怎么用到后面会讲到

7. Word Boundaries

单词界

\<\> \b\b
\<cat\> 只匹配整个单词cat
这个我以前没见过….话说最近的egrep版本才有这个功能……

下图很好的解释了哪些地方算是单词界

egrep 和grep 中用的是\<\>
但是在 PCRE 中 都是 \b\b
用 \B 表示 \b的非

8. Optional Items

?  可有可无
colou?r  匹配 color 和 colour

9. Repetition

* 重复0次以上

+  重复1次以上
{}  范围重复

[0-9]* 匹配所有数字,而且还可以没有
[0-9]+ 匹配所有数字,至少得有一个数字
[a-zA-Z]{1,5} 匹配1到5个字母

10. Parentheses and Backreferences

括号和回调(我是这么翻译的……)
匹配与前面相同的某一部分
\<([A-Za-z]+)’s•+\1\> 就可以匹配What’s What
\1只匹配与([A-Za-z]+)匹配过的相同的字符, 所以What’s that就不能匹配成功

*egrep命令行记得要用双引号把表达式括起来, 否则单引号会转义
     %egrep “\<([A-Za-z]+)’s•+\1\>” wordlist
想想\<([A-Za-z]+)’s(•*)\1\2\>匹配 What’s•What•吗?

11. The Great Escape

转义
括号()在正则中将会被转义表示优先, 在他们前面加反斜杠来防止被转义
如\(cool\) 就可以匹配(cool)

而一些没有转义意义的字符加反斜杠则会有特定的转义
如之前学的一些 \<  \>  \1 \2  等等

总结

下面是不同工具对上述基本表达式的支持, 左边4个都是unix系统常用的工具
可见右边的3种高级程序语言用所支持的都没有区别