JavaChen Blog

JSF中EL表达式之this扩展

JavaChen — Tue, 14 Feb 2012 21:14:19 +0800

本篇文章来自以前公司的一套jsf+seam+Hibernate的一套框架，其对jsf进行了一些改进，其中包括:EL表达式中添加this，通过jsf的渲染实现权限控制到按钮等等。JSF表达式中添加this，主要是为了在facelets页面使用this关键字引用（JSF自动查找）到当前页面对应的pojo类，详细说明见下午。因为，本文的文章是公司同事整理的，本文作者仅仅是将其分享出来，供大家参考思路，如果有什么不妥的话，请告知。

EL表达式this扩展
在业务系统中，大量页面具有大量区域是相似或者相同的，或者可能根据某些局部特征的变化具有一定的变化，jsf中通过facelet模板功能可以达到一定程度的页面重用，从而减轻开发人员编辑和拷贝一些页面代码，达到重用的目的。然而，她们具有如下限制：

1.Java语言作为一种典型的OO语言，通过抽象、继承等功能，可以大量重用已经实现或者在父类中已经存在的属性和方法等。模板技术作为一种静态加载和内容替换，无法充分利用面向对象的继承功能
2.由于Jsf/jsp框架采用视图和动作分离的模型，多个相似功能在不同的页面实现中由于页面对应点动作类不同因而必须使用复制的方法；
3.模板中使用EL表达式与后台动作类交互，这种交互是基于绝对名称的，不同的网页对应的动作类是完全不同的，因此很难重用和利用面向对象的特征。

我们需要一种新的功能，实现：
1.模板的应用特种可以参照OO的继承特种，即模板的对模板的引用可以看成一种继承，这种继承可以和java的OO是一致的
2.多个页面和多个独立java后台程序相同部分完全可以抽离出来，不依赖它们是否继承关系、只需保证他们具有相同的属性或者方法
3.动态映射功能，即在满足上述基础上可以实现页面和后台实现类的属性和方法的自动映射
4.兼容标准的EL表达式

我们将上述功能处理为“this”表达式。其功能模型为：

页面A和页面B分别引用了通用功能T,内含this相关的El表达式，通过分析处理，分别映射到对应的页面动作类的属性A.name和B.name。A和B可以从相同的基类C派生而来，只需C类实现了name属性即可，A类和B类也可以毫不相关，但是它们具有相同的属性name。

动作类和页面的一致性保证
为了有效实现this表达式，我们实现如下映射规则：
1.名称为小写方式，不管页面如何命名，对应的后台类的jsf标识符都转换为小写
2.页面和相应的后台类以相同命名方式，页面的目录转化为后台类的包名，名称通过点分隔包名，如根目录的a.xhtml对应的后台类名称为A.java，其唯一jsf标识名称为“a”，test/b.xhtml的后台类为test/B.java，其唯一jsf标识为“test.b”
1.1.2. “this”EL表达式算法

算法流程如下图：

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

翻译：First JBoss Seam tutorial

JavaChen — Sun, 12 Feb 2012 22:49:11 +0800

说明

该文章翻译于《First JBoss Seam tutorial》，原文作者：Sebastian Hennebrueder，翻译者:JavaChen。

原文链接：http://www.laliluna.de/articles/posts/first-jboss-seam.html

一步一步的创建Jboss seam应用

介绍

这篇教程展示如何使用JBoss Seam、JSF和Facelets创建一个应用。我将为Tomcat和JBoss应用服务器列出一个配置。此外，你可以学习如何使用Maven定义依赖。

版本

教程版本：1.0 作者：Sebastian Hennebrueder

包版本

1.Seam 2.0.1.GA
2.Tomcat 6
3.JBoss Application Server 4.2 (not 4.0)

下载

教程PDF：
http://www.laliluna.de/download/first-jboss-seam-en.pdf
项目例子代码
http://www.laliluna.de/download/first-jboss-seam-source.zip

创建项目

使用你喜欢的IDE创建一个web工程。我将使用一个WAR包开发。

Seam配置文件

我们需要下面的配置文件。

components.xml
该文件配置Seam和我们的组件。我更喜欢使用注解配置文档组件而不用这个文件配置，但是在这里我们还是在该文件里定义。

位置：WAR包的WEB-INF目录下，JAR包的META-INF目录下。这里，我们使用的是WAR包。

告诉Seam我们不想让他管理事物（此刻）。

^?[Copy to clipboard]View Code XML

< ?xml version="1.0" encoding="UTF-8"?>
<components xmlns="http://jboss.com/products/seam/components"
  xmlns:core="http://jboss.com/products/seam/core"
  xmlns:persistence="http://jboss.com/products/seam/persistence"
  xmlns:security="http://jboss.com/products/seam/security"
  xmlns:drools="http://jboss.com/products/seam/drools"
  xmlns:web="http://jboss.com/products/seam/web"
  xmlns:mail="http://jboss.com/products/seam/mail"
  xmlns:transaction="http://jboss.com/products/seam/transaction"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation=
      "http://jboss.com/products/seam/core 
       http://jboss.com/products/seam/core-2.0.xsd
       http://jboss.com/products/seam/persistence 
       http://jboss.com/products/seam/persistence-2.0.xsd
       http://jboss.com/products/seam/security 
       http://jboss.com/products/seam/security-2.0.xsd
       http://jboss.com/products/seam/web 
       http://jboss.com/products/seam/web-2.0.xsd
       http://jboss.com/products/seam/drools 
       http://jboss.com/products/seam/drools-2.0.xsd
       http://jboss.com/products/seam/mail 
       http://jboss.com/products/seam/mail-2.0.xsd
       http://jboss.com/products/seam/transaction 
       http://jboss.com/products/seam/transaction-2.0.xsd
       http://jboss.com/products/seam/components 
       http://jboss.com/products/seam/components-2.0.xsd">
 
  <core:init transaction-management-enabled="false"/>
  <transaction:no -transaction/>
 
</components>

seam.properties

包括一些可以在components.xml使用的设置。除了这，他仅仅是标记告诉Seam一个存档文件（WAR或者JAR）包括Seam组件。所以只需要创建一个空文件。

位置：源文件的根目录下（你的Java classes目录下）。

pages.xml
包括导航规则，可以和JSF的faces-config.xml文件想比较有什么区别，此外我们还可以添加权限规则。

位置：一个WAR工程的 WEB-INF 目录下。

^?[Copy to clipboard]View Code XML

< ?xml version="1.0" encoding="UTF-8"?>
<pages xmlns="http://jboss.com/products/seam/pages"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://jboss.com/products/seam/pages 
   http://jboss.com/products/seam/pages-2.0.xsd"
   no-conversation-view-id="/home.xhtml"
   login-view-id="/login.xhtml">
 
 <page view-id="*">
  <navigation>
   <rule if-outcome="home">
    <redirect view-id="/home.xhtml"/>
   </rule>
  </navigation>
 </page>
 
 <exception>
  <redirect view-id="/error.xhtml">
   <message>Unexpected error, please try again</message>
  </redirect>
 </exception>
 
</pages>

faces-config.xml
普通的JavaServer Faces配置文件。Seam的默认渲染器是JavaServer Faces，这就是我们需要这个配置文件的原因。
我们定义默认的和可支持的语言以及资源文件的前缀。
本例子将会使用facelets用于渲染。这就是为什么我们要在该文件中定义facelets视图处理器的原因。
不要在该文件中添加JSF的导航规则，因为Seam会使用pages.xml来导航。

^?[Copy to clipboard]View Code XML

< ?xml version='1.0' encoding='UTF-8'?>
<faces -config version="1.2"
    xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
    http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">
  <application>
    <message -bundle>messages</message>
    <locale -config>
 <default -locale>en</default>
 <supported -locale>en</supported>
    </locale>
    <view -handler>com.sun.facelets.FaceletViewHandler</view>
  </application>
</faces>

web.xml
位置：应该保存于webapp目录下

定义Seam和JSF的特定设置、过滤器和servlet。

^?[Copy to clipboard]View Code XML

< ?xml version="1.0" ?>
<web -app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee"
 xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
  http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
 id="WebApp_ID" version="2.5">
 
   <!-- Seam -->    
   <listener>
      </listener><listener -class>org.jboss.seam.servlet.SeamListener</listener>
 
   <filter>
        </filter><filter -name>Seam Filter</filter>
        <filter -class>org.jboss.seam.web.SeamFilter</filter>
 
    <filter -mapping>
        </filter><filter -name>Seam Filter</filter>
        <url -pattern>/*</url>
 
 
  <!-- Facelets development mode (disable in production) --> 
   <context -param>
      <param -name>facelets.DEVELOPMENT</param>
      <param -value>true</param>
   </context>
 
   <!-- JSF -->    
   <context -param>
      <param -name>javax.faces.STATE_SAVING_METHOD</param>
      <param -value>client</param>
   </context>    
   <context -param>
      <param -name>javax.faces.DEFAULT_SUFFIX</param>
      <param -value>.xhtml</param>
   </context>
   <servlet>
      </servlet><servlet -name>Faces Servlet</servlet>
      <servlet -class>javax.faces.webapp.FacesServlet</servlet>
      <load -on-startup>1</load>
 
   <servlet -mapping>
      </servlet><servlet -name>Faces Servlet</servlet>
      <url -pattern>*.seam</url>
 
</web>

添加libraries

我们创建了一个配置最小化的JBoss Seam例子。所以libraries中你不必包括Seam Email、Seam PDF等等。
JBoss4.2已经提供了jsf-api和jsf-impl包。所以不用添加他们。当然Tomcat或Jetty需要添加他们。

手动添加
拷贝下面jar文件到WEB-INF目录下。你可以在你下载的JBoss Seam的lib目录下找到他们。
dom4j-1.6.1-jboss.jar
commons-beanutils-1.7.0.jar
hibernate-validator-3.0.0.ga.jar
javassist-3.3.ga.jar
jboss-el-2.0.1.GA.jar
jboss-seam-2.0.1.GA.jar
jboss-seam-ui-2.0.1.GA.jar
jsf-api-1.2_04-p02.jar
jsf-facelets-1.1.11.jar
jsf-impl-1.2_04-p02.jar
jta-1.1.jar
persistence-api-1.0.jar

使用Maven
可选的，你可以使用Maven。我喜欢用他来管理jar包。我们需要一个JBoss仓库。我的IntelliJ工程无意中部署了Maven加载的 el-api.jar。这在Tomcat 6和JBoss 4.2中会产生一个问题。确定该文件没有被部署。

下面是一个我们需要的pom.xml文件

^?[Copy to clipboard]View Code XML

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
  http://maven.apache.org/maven-v4_0_0.xsd">
  <modelversion>4.0.0</modelversion>
  <groupid>de.laliluna</groupid>
  <artifactid>seamWeb</artifactid>
 
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>seamWeb</name>
  <url>http://maven.apache.org</url>
 
  <build>
    <finalname>seamWeb</finalname>
    <plugins>
      <plugin>
        <groupid>org.apache.maven.plugins</groupid>
        <artifactid>maven-compiler-plugin</artifactid>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>
      <plugin>
        <groupid>org.apache.maven.plugins</groupid>
        <artifactid>maven-idea-plugin</artifactid>
        <configuration>
          <downloadsources>true</downloadsources>
          <downloadjavadocs>true</downloadjavadocs>
        </configuration>
      </plugin>
    </plugins>
 
  </build>
  <repositories>
    <repository>
      <id>repository.jboss.org</id>
      <url>http://repository.jboss.org/maven2</url>
      <snapshots>
        <enabled>true</enabled>
      </snapshots>
    </repository>
  </repositories>
 
  <dependencies>
 
    <!-- JBoss Seam minimal -->
    <dependency>
      <groupid>org.jboss.seam</groupid>
      <artifactid>jboss-seam</artifactid>
      <version>2.0.1.GA</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupid>org.jboss.seam</groupid>
      <artifactid>jboss-seam-ui</artifactid>
      <version>2.0.1.GA</version>
      <scope>compile</scope>
    </dependency>
    <!-- Seam makes use of Hibernate validator and sadly
     depends on JTA and JPA even if we don't use it -->
    <dependency>
      <groupid>javax.transaction</groupid>
      <artifactid>jta</artifactid>
      <version>1.1</version>
    </dependency>
    <dependency>
      <groupid>javax.persistence</groupid>
      <artifactid>persistence-api</artifactid>
      <version>1.0</version>
    </dependency>
    <dependency>
      <groupid>org.hibernate</groupid>
      <artifactid>hibernate-validator</artifactid>
      <version>3.0.0.ga</version>
    </dependency>
 
    <!-- JSF and facelets -->
    <dependency>
      <groupid>javax.faces</groupid>
      <artifactid>jsf-api</artifactid>
      <version>1.2_04-p02</version>
    </dependency>
    <dependency>
      <groupid>javax.faces</groupid>
      <artifactid>jsf-impl</artifactid>
      <version>1.2_04-p02</version>
    </dependency>
    <dependency>
      <groupid>com.sun.facelets</groupid>
      <artifactid>jsf-facelets</artifactid>
      <version>1.1.11</version>
    </dependency>
 
 
    <!-- I like to have log4j without Hibernate as well -->
    <dependency>
      <groupid>log4j</groupid>
      <artifactid>log4j</artifactid>
      <version>1.2.14</version>
      <scope>compile</scope>
    </dependency>
 
  </dependencies>
</project>

Hello world

在根目录创建一个index.jsp文件。他会将我们重定向到hello页面。

^?[Copy to clipboard]View Code JSP

1	< % response.sendRedirect("hello.seam"); %>

创建一个facelets页面hello.xhtml。

^?[Copy to clipboard]View Code XML

< ?xml version="1.0" encoding="UTF-8"?>
< !DOCTYPE html
     PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:s="http://jboss.com/products/seam/taglib"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:ui="http://java.sun.com/jsf/facelets">
  <head>
    <title>Hello world</title>
  </head>
  <body>
  <p>Welcome to your first Seam application</p>
 
  </body>
</html>

部署你的应用到Tomcat或者JBoss并且测试该页面。在我的工程中，我使用下面的url：

http://localhost:8080/seamWeb/

编写一个Seam组件

下一步改进hello页面。
我们的应用要处理hedgehogs并且第一件事是打印出hedgehogs 的列表。

^?[Copy to clipboard]View Code JAVA

package de.laliluna.seam;
 
public class Hedgehog {
 
  private String name;
 
  public Hedgehog() {
  }
 
  public String getName() {
    return name;
  }
 
  @Override
  public String toString() {
    final StringBuilder sb = new StringBuilder();
    sb.append("Hedgehog");
    sb.append("{name='").append(name).append(''');
    sb.append('}');
    return sb.toString();
  }
 
  public void setName(String name) {
    this.name = name;
  }
 
  public Hedgehog(String name) {
    this.name = name;
  }
}

创建一个HedgehogService类。他是一个Seam组件。Name注解标记他是个一个组件并定义他的名称。此外，我们可以使用Scope注解定义他将会被放置到哪里的上下文。

我们稍后将会看到我们可以使用名称来引用该组件。我们的服务类为JSF data table提供了一个数据模型-hedgehogs。

^?[Copy to clipboard]View Code JAVA

package de.laliluna.seam;
 
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.annotations.datamodel.DataModel;
import org.jboss.seam.ScopeType;
import java.util.List;
import java.util.ArrayList;
 
@Name("hedgehogService")
@Scope(ScopeType.SESSION)
public class HedgehogService {
 
  @DataModel
  private List<hedgehog> hedgehogs;
 
  public HedgehogService() {
    hedgehogs = new ArrayList</hedgehog><hedgehog>();
    hedgehogs.add(new Hedgehog("Holger"));
    hedgehogs.add(new Hedgehog("Pete"));
    hedgehogs.add(new Hedgehog("Sebastian"));
  }
 
  public String getHello() {
    return "Your hedgehogService says hello";
  }
}
</hedgehog>

最后，我们添加一些信息到English资源文件。
在src目录下创建一个messages_en.properties文件。

^?[Copy to clipboard]View Code PROPERTIES

1 2	hello=Welcome to your Seam application hedgehog.name=Name

改进hello.xhtml文件打印hedgehogs，提示信息来自资源文件和getHello方法。

^?[Copy to clipboard]View Code XML

< ?xml version="1.0" encoding="UTF-8"?>
< !DOCTYPE html
        PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:s="http://jboss.com/products/seam/taglib"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:ui="http://java.sun.com/jsf/facelets">
<head>
  <title>Hello</title>
</head>
<body>
<p>#{messages.hello}</p>
 
<p>#{hedgehogService.hello}</p>
 
<h:datatable value="#{hedgehogs}" var="h">
  <h:column>
    <f:facet name="header">#{messages['hedgehog.name']}</f:facet>
    #{h.name}
  </h:column>
</h:datatable>
</body>
</html>

这就是所有的，再一次测试你的应用。

调试技巧

当你的应用启动的时候，将会打印所有被创建（Seam和你）的组件和他们所处的上下文。验证你新建的组件是否正确。
Seam有一个调试页面显示一些信息。
添加jboss-seam-debug.jar到WEB-INF目录。可选的，添加下面依赖到pom.xml文件。

^?[Copy to clipboard]View Code XML

 <dependency>
      <groupid>org.jboss.seam</groupid>
      <artifactid>jboss-seam-debug</artifactid>
      <version>2.0.1.GA</version>
    </dependency>

在components.xml中激活调试模式。

^?[Copy to clipboard]View Code XML

1	<core:init transaction-management-enabled="false" debug="true"/>

打开你的浏览器并输入下面url进入调试页面

http://localhost:8080/seamWeb/debug.seam

添加Hibernate
这一步中我们将会从数据库中加载hedgehogs。

本例中，我将会使用PostgreSQL数据库。想改变数据库，只需要修改 hibernate.cfg.xml的设置并且替换jdbc驱动。

添加libraries

额外的，我们需要添加以下文件
antlr-2.7.6.jar
asm-1.5.3.jar
commons-beanutils-1.7.0.jar
asm-attrs-1.5.3.jar
hibernate-3.2.5.ga.jar
commons-collections-2.1.1.jar
c3p0-0.9.1.2.jar
postgresql-8.2-507.jdbc3.jar
backport-util-concurrent-3.0.jar
commons-logging-1.0.4.jar
hibernate-annotations-3.3.0.ga.jar
hibernate-commons-annotations-3.3.0.ga.jar
ehcache-1.3.0.jar
cglib-2.1_3.jar
jsr107cache-1.0.jar

如果你使用Maven，添加下面依赖

^?[Copy to clipboard]View Code XML

<dependency>
   <groupid>org.hibernate</groupid>
   <artifactid>hibernate</artifactid>
   <version>3.2.5.ga</version>
   <scope>compile</scope>
 </dependency>
 <dependency>
   <groupid>c3p0</groupid>
   <artifactid>c3p0</artifactid>
   <version>0.9.1.2</version>
   <scope>compile</scope>
 </dependency>
 <dependency>
   <groupid>net.sf.ehcache</groupid>
   <artifactid>ehcache</artifactid>
   <version>1.3.0</version>
 </dependency>
 <dependency>
   <groupid>org.hibernate</groupid>
   <artifactid>hibernate-annotations</artifactid>
   <version>3.3.0.ga</version>
   <scope>compile</scope>
 </dependency>
 <dependency>
   <groupid>org.hibernate</groupid>
   <artifactid>hibernate-commons-annotations</artifactid>
   <version>3.3.0.ga</version>
 </dependency>
 <!-- other -->
 <dependency>
   <groupid>postgresql</groupid>
   <artifactid>postgresql</artifactid>
   <version>8.2-507.jdbc3</version>
   <scope>compile</scope>
 </dependency>

Configuration

我们需要在源代码的根目录下添加一个hibernate.cfg.xml文件。

^?[Copy to clipboard]View Code XML

< ?xml version='1.0' encoding='UTF-8'?>
< !DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 
<hibernate -configuration>
<session -factory>
 <!--  postgre SQL configuration-->
 <property name="connection.url">
  jdbc:postgresql://localhost:5432/learninghibernate
 </property>
 <property name="connection.username">postgres</property>
 <property name="connection.password">p</property>
 <property name="connection.driver_class">
 org.postgresql.Driver
 </property>
 <property name="dialect">
  org.hibernate.dialect.PostgreSQLDialect
 </property>
 <property name="c3p0.max_size">4</property>
 <property name="c3p0.min_size">1</property>
 
 <property name="cache.provider_class">
  org.hibernate.cache.EhCacheProvider
 </property>
 <property name="transaction.factory_class">
  org.hibernate.transaction.JDBCTransactionFactory
 </property>
  <property name="transaction.flush_before_completion">true</property>
  <property name="connection.release_mode">after_statement</property>  
  <property name="hbm2ddl.auto">update</property>
 <property name="default_batch_fetch_size">4</property>
 <mapping class="de.laliluna.seam.Hedgehog" />
</session>
</hibernate>

在components.xml中你需要修改事物处理方式。工厂仅仅是为了解决命名问题。我们不能使用session作为名称注入到Hibernate session中，但是我想在我的应用中使用这个组件名称。

^?[Copy to clipboard]View Code XML

<!--
  <core:init transaction-management-enabled="false" debug="true"/>
  <transaction:no -transaction/>
  -->
 
  <core:init debug="true"/>
  <persistence:hibernate -session-factory name="hibernateSessionFactory"/>
  <persistence:managed -hibernate-session name="xsession"
                           auto-create="true"
                           session-factory="#{hibernateSessionFactory}"/>
  <transaction:hibernate -transaction session="#{xsession}"  />
  <factory name="session"
           scope="STATELESS"
           auto-create="true"
           value="#{xsession}"/>

代码

我们必须添加加载和保存代码到HedgehogService 类中。
首先，我们需要注入session组件到我们的类中。
然后我们定义Data model有一个工程方法加载hedgehogs。

我改变了Scope的值为conversation 以便我们在创建一个新的hedgehog时候可以重新加载所有hedgehog。

^?[Copy to clipboard]View Code JAVA

@Name("hedgehogService")
@Scope(ScopeType.CONVERSATION)
public class HedgehogService implements Serializable {
  @In
  private Session session;
 
  @DataModel
  private List<hedgehog> hedgehogs;
 
  @Factory("hedgehogs")
  public void loadHedgehogs() {
    hedgehogs = session.createCriteria(Hedgehog.class).list();
  }
 
  public void createHedgehog() {
    session.save(new Hedgehog("Name " + new Date()));
  }
< ?pre>
 
Hedgehog类需要Hibernate的注解进行定义。
<pre lang="java">
@Entity
public class Hedgehog implements Serializable{
 
  @Id
  @GeneratedValue(strategy = GenerationType.SEQUENCE)
  private Long id;
 
// getter and setter are omitted

前端页面

我们改进hello.xhtml页面。我们添加一个链接用于创建一个新的hedgehogs。

^?[Copy to clipboard]View Code XML

<s:link action="#{hedgehogService.createHedgehog}">Create a hedgehog</s:link>
 
<s:fragment rendered="#{empty hedgehogs}">
  No hedgehogs
</s:fragment>
<h:datatable value="#{hedgehogs}" var="h" rendered="#{! empty hedgehogs}">
  <h:column>
    <f:facet name="header">#{messages['hedgehog.name']}</f:facet>
    #{h.name}
  </h:column>
</h:datatable>

结论

使用JBoss Seam创建一个Web应用是非常简单的。虽然该框架被设计于集成JSF和EJB3，我们可以在Tomcat应用服务器中的Pojo类上使用。我们甚至可以获得免费的事物管理。
手动创建一个应用的有点是我们可以仅仅添加需要的jar包而不需要添加整个package包。

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

Ext读取xml文件生成动态表格和表单(续)

JavaChen — Tue, 31 Jan 2012 16:28:12 +0800

很多人向我要《Ext读取xml文件生成动态表格和表单》一文的源代码，故花了些时间将源代码整理出来，并重新编写此文，分享当时的技术思路。

《Ext读取xml文件生成动态表格和表单》一文需要的文件有：
1.html文件，此处以SASC.search.MtrUse.html为例
2.Extjs相关文件,见SASC.search.MtrUse.html文件中的引用
3.工具类，DomUtils.js
4.核心js类:SASC.extjs.search.MtrUse.js
5.java代码

详细html和js代码见相关文件，这里先描述思路。

首先
通过一个事件打开一个弹出窗口，该窗口的url指向SASC.search.MtrUse.html文件，并附带参数xmlFile，xmlFile的值为xml文件名称，其存于服务器的某一路径下面。如：“../SASC.search.MtrUse.html?xmlFile=PC_MTRREPLACE_IMP.xml” .PC_MTRREPLACE_IMP.xml文件的放置路径见DomUtils.js文件中的说明。

在这里，前台会读取该xml生成ext界面，后天会从xml文件读取sql语句等信息，详细信息见java代码。
进入SASC.search.MtrUse.html页面，执行ext的初始化方法时，会先通过当前页面的url中获取xmlFile参数的值（调用getForwardXmlUrl(getQsValue(‘xmlFile’))），得到xml文件的服务器路径，然后通过javascript的解析该xml文件，渲染出ext界面,这部分代码见SASC.extjs.search.MtrUse.js文件内的initStoreData(xmlObj) 方法。
需要说明的是，xml文件是按照一定规律编写的，详细的参考xml文件内容，以及解析xml文件的相关方法。你可以重新定义该xml的结构，然后修改解析xml文件的方法。

然后

初始化完ext界面之后，会获取表格数据，这部分使用了struts，这不是本文重点，故不做介绍。

最后
相关文件打包见：
http://vdisk.weibo.com/s/2enQS

说明
如果还有什么不懂，欢迎email：javachen.june#gmail.com

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

2011年度年终总结

JavaChen — Tue, 31 Jan 2012 15:19:10 +0800

2011年工作总结，只能算是七个月的工作总结，在这七个月里学到了许多、收获了许多、感悟了许多。以下是对这六个月的一个回顾与总结。

来公司最初的两个月主要负责云计算相关产品的调研工作，相关云计算产品有：Eucalyptus、OpenNebula、OpenStack。在这两个月里，对云计算的原理、服务、架构以及安装和部署有了初步的了解于实践，并积累了一些文档。在一次又一次的安装部署过程中，体验到了失败的痛苦、无助的迷茫、成功的喜悦，深刻的意识到自身在linux方面存在的不足；强烈的感觉到有必要学习一些语言，如Shell、Python、Groovy、Ruby等等。2012年，打算将工作环境切换到ubuntu，并向叶凌学习ubuntu相关方面的知识；打算学习rhl6相关课程，遇到不懂的问题向同事提问、学习。

随后在公司里参与了报表项目的开发，在这次开发中较快的熟悉了Spring+JPA框架、掌握了dhtmlx的使用、接触到了postgresql数据库，顺利的完成了各项开发工作。通过这个项目，熟悉了公司的项目管理方式、版本控制、代码开发规范等等。总体来说，公司在代码复查方面做的不够，项目开发方面没有形成一套成型的开发框架，并且，项目于项目之间在一些同时使用的相关技术上面的沟通于交流做的不够。希望，公司以后能够制定一些编码规范、引入代码审查、形成一套成型的可重复利用的开发框架或是基础开发包。

剩下的时间接触了Pentaho BI，在整体上了解了Pentaho相关组件之后，开始了阅读其代码、特别是阅读了其分析报表和交互式报表的实现方式以及一些底层基础代码。在阅读代码过程中，深切的体会到有必要深入的学习LDAP以及数据挖掘相关的理论知识。当然，更多的时间花在了kettle的学习和使用以及修改、扩展代码上。2012年，LDAP和kettle将会是一个工作重点。2011年，做了三次Pentaho的服务，通过这三次服务意识到有必要加强自己的沟通交流能力、储备足够的专业知识、灵活应对客户的要求和需求。

2011年，工作上存在一些不足。在调研云计算过程中没有整理、形成足够详细的文档，自己所做的工作没有及时分享；在工作中没有及时提交项目周报；没有及时的跟踪、检查分配下去的任务完成情况，对新人的指导不够；编写文档时候，没有可参考的模版，导致文档编写不规范；在与客户的交流中底气不足、表达能力不够；下班之后惰性较强，缺少自主学习性；博客文章篇数较少，平时的总结与分享不够积极等等。

2012年，将会从以下方面指导自己的工作：以CE为目标提高linux水平，多参加云计算相关活动、多学习云计算开源产品；更加深入的掌握、理解Kettle源码及使用，掌握数据挖掘相关理论知识，争取创建一个Pentaho社区、一个QQ分享群，培养新人，希望能够将Pentaho的咨询服务工作更多交给其他人完成；在项目管理上有所进步；及时总结自己存在的不足，发现问题，不断进步，通过博客、微博及时记录、分享一些技术心得。2012年，是职业生涯的第三年，在这一年希望能够深入理解Spring、Jboss、Pentaho、缓存、云计算、架构等技术，希望自己在技术方面不断成长的同时，在项目管理方面能有所进步；希望自己在工作上、生活里能够有更多的自主性、创造性。

2012年，我们有所希望、有所期待。希望公司不断完善公司规则制度、注重团队培养、关心每一个同事的成长；希望公司能够多分享资源、多交流心得；希望每一个同事都能忙碌着、进步着并快乐着，大家一起努力，一起进步；期待公司在开源方面能够走的更远，公司各方面能够更上一层楼！

2012年，期望明天会更好！

By the time your rss reader get this post here is 2 comments ,Welcome you come to leave your opinion !

使用kettle数据迁移添加主键和索引

JavaChen — Thu, 05 Jan 2012 17:51:13 +0800

Kettle是一款国外开源的etl工具，纯java编写，绿色无需安装，主要用于数据抽取、转换、装载。kettle兼容了市面上几十种数据库，故用kettle来做数据库的迁移视乎是个不错的选择。

kettle的数据抽取主要在于抽取数据，而没有考虑数据库的函数、存储过程、视图、表结构以及索引、约束等等，而这些东西恰恰都是数据迁移需要考虑的事情。当然，如果在不考虑数据库中的函数、存储过程、视图的情况下，使用kettle进行数据的迁移还算是一个可行的方案。

这篇文章主要是讲述在使用kettle进行数据库的迁移的时候如何迁移主键和索引，为什么要迁移主键和索引？异构数据库之间的迁移很难无缝的实现自定义函数、存储过程、视图、表结构、索引、约束以及数据的迁移，所以多数情况下只需要异构数据库之间类型兼容、数据一致就可以了。但是在有些情况下需要对输出表进行查询以及数据比对的时候，需要有主键和索引方便对比和加快查询速度。

先来看看kettle中的一些组件。下图是kettle中的一个表输出组件。

在该组件里可以指定表名、字段等信息，并且还可以建表的sql语句。打开建表的sql语句，你可以看到该语句里只指定了字段名称和类型，没有指定主外键、约束、和索引。显然，该组件只是完成了数据的输出并没有将表的主键迁移过去。

下图是kettle中纬度更新/查询的组件。

该组件可以指定输出表名、映射字段、纬度字段、并且指定主键（图中翻译为关键字段），该组件比表输出组件多了一个功能，即指定主键。

从上面两个组件中可以看出，kettle实际上预留了设置主键的接口，具体的接口说明需要查看api或者源代码，只是kettle没有智能的查处输入表的主键字段，而是需要用户在kettle ui界面指定一个主键名称。

如果现在想使用kettle实现异构数据库的数据以及主键和索引的迁移，有没有一个完整方便的解决方案呢？我能想到的解决方案如下：
1.使用kettle向导中的多表复制菜单进行数据库的迁移，这只能实现数据的迁移还需要额外的方法添加主键和索引，你可以手动执行一些脚步添加约束。
2.针对源数据库中的每一张表创建一个转换，转换中使用纬度更新/查询组件，在该主键中指定主键。创建完所有的转换之后，创建一个作业将这些转换串联起来即可。
3.扩展kettle向导中的多表复制菜单里的功能，在该功能创建的作业中添加一些节点用于添加输出表的主键和索引。这些节点可以是执行sql语句的主键，故只需要通过jdbc代码获取添加主键和索引的sql语句。

方案1需要单独执行脚步实现添加主键和索引，创建或生成这些脚步需要些时间；方案2需要针对每个表认为的指定主键，工作量大，而且无法实现添加索引；方案3最容易实现和扩展。

下面是方案3的具体的实现。

首先需要在每一个表的建表语句节点和复制数据节点之后添加一个执行sql语句的节点，该节点用于添加主键和索引。
多表复制向导的核心代码在src-db/org.pentaho.di.ui.spoon.delegates.SpoonJobDelegate.java的public void ripDBWizard()方法中。该方法如下：

^?[Copy to clipboard]View Code JAVA

public void ripDBWizard(final int no) {
	final List databases = spoon.getActiveDatabases();
	if (databases.size() == 0)
		return;
 
	final RipDatabaseWizardPage1 page1 = new RipDatabaseWizardPage1("1",
			databases);
	final RipDatabaseWizardPage2 page2 = new RipDatabaseWizardPage2("2");
	final RipDatabaseWizardPage3 page3 = new RipDatabaseWizardPage3("3",
			spoon.getRepository());
	Wizard wizard = new Wizard() {
		public boolean performFinish() {
			try {
				JobMeta jobMeta = ripDBByNo(no, databases,
					page3.getJobname(), page3.getRepositoryDirectory(),
					page3.getDirectory(), page1.getSourceDatabase(),
					page1.getTargetDatabase(), page2.getSelection());
 
				if (jobMeta == null)
					return false;
 
				if (page3.getRepositoryDirectory() != null) {
					spoon.saveToRepository(jobMeta, false);
				} else {
					spoon.saveToFile(jobMeta);
				}
 
				addJobGraph(jobMeta);
				return true;
			} catch (Exception e) {
				new ErrorDialog(spoon.getShell(), "Error",
						"An unexpected error occurred!", e);
				return false;
			}
		}
 
		public boolean canFinish() {
			return page3.canFinish();
		}
	};
 
	wizard.addPage(page1);
	wizard.addPage(page2);
	wizard.addPage(page3);
 
	WizardDialog wd = new WizardDialog(spoon.getShell(), wizard);
	WizardDialog.setDefaultImage(GUIResource.getInstance().getImageWizard());
	wd.setMinimumPageSize(700, 400);
	wd.updateSize();
	wd.open();
}

该方法主要是创建一个向导，该向导中包括三个向导页，第一个向导页用于选择数据库连接：源数据库和目标数据库连接；第二个向导页用于选表；第三个向导页用于指定作业保存路径。在向导完成的时候，即performFinish()方法里，会根据选择的数据源和表生成一个作业，即JobMeta对象。
创建Jobmeta的方法为：

^?[Copy to clipboard]View Code JAVA

public JobMeta ripDB(final List databases,final String jobname, final
    RepositoryDirectoryInterface repdir,final String directory, final DatabaseMeta
    sourceDbInfo,final DatabaseMeta targetDbInfo, final String[] tables){
 //此处省略若干代码
}

该方法主要逻辑在下面代码内：

^?[Copy to clipboard]View Code JAVA

IRunnableWithProgress op = new IRunnableWithProgress() {
	public void run(IProgressMonitor monitor)
	 throws InvocationTargetException, InterruptedException {
           //此处省略若干代码
        }
}

上面代码中有以下代码用于遍历所选择的表生成作业中的一些节点：

^?[Copy to clipboard]View Code JAVA

1
2
3

for (int i = 0; i &lt; tables.length &amp;&amp; !monitor.isCanceled(); i++) {
    //此处省略若干代码
}

针对每一张表先会创建一个JobEntrySQL节点，然后创建一个转换JobEntryTrans，可以在创建转换之后再创建一个JobEntrySQL节点，该节点用于添加主键和索引。
这部分的代码如下：

^?[Copy to clipboard]View Code JAVA

String pksql = JdbcDataMetaUtil.exportPkAndIndex(
		sourceDbInfo, sourceCon, tables[i],
		targetDbInfo, targetCon, tables[i]);
 
if (!Const.isEmpty(pksql)) {
	location.x += 300;
	JobEntrySQL jesql = new JobEntrySQL(
		BaseMessages.getString(PKG,"Spoon.RipDB.AddPkAndIndex")
			+ tables[i] + "]");
	jesql.setDatabase(targetDbInfo);
	jesql.setSQL(pksql);
	jesql.setDescription(BaseMessages.getString(PKG,
			"Spoon.RipDB.AddPkAndIndex")
			+ tables[i]
			+ "]");
 
	JobEntryCopy jecsql = new JobEntryCopy();
	jecsql.setEntry(jesql);
	jecsql.setLocation(new Point(location.x, location.y));
	jecsql.setDrawn();
	jobMeta.addJobEntry(jecsql);
 
	// Add the hop too...
	JobHopMeta jhi = new JobHopMeta(previous, jecsql);
	jobMeta.addJobHop(jhi);
	previous = jecsql;
}

获取添加主键和索引的sql语句，主要是采用jdbc的方式读取两个数据库，判断源数据库的表中是否存在主键和索引，如果有则返回添加主键或索引的sql语句。这部分代码封装在JdbcDataMetaUtil类中。
该代码见：https://gist.github.com/1564353.js

最后的效果图如下：

说明：
1.以上代码使用的是jdbc的方法获取主键或索引，不同的数据库的jdbc驱动实现可能不同而且不同数据库的语法可能不同，故上面代码可能有待完善。
2.如果一个数据库中存在多库并且这多个库中有相同的表，使用上面的代码针对一个表名会查出多个主键或索引。这一点也是可以改善的

Here is no comments yet by the time your rss reader get this, Do you want to be the first commentor? Hurry up

您可能也喜欢：
JSF Converter	JSF入门	JSF动作事件	JSF国际化	JSF1.2中 ValueExpression的用法
无觅

您可能也喜欢：
Jboss Seam的注解	Seam中的log日志记录方法	Seam管理hibernate会话	Seam中cos多文件上传出现异常	如何设置jboss自动启动
来自无觅网络的相关文章：
IE中:first-child失效的解决方案_CSS帝国 (@cssking)	gravatar全球通用头像使用教程! (@wx)	502网缩使用教程,bug提交! (@wx)	提高Adsense收入 (@netsh)	The 13th ICCC begins its first day (@tumutanzi)
无觅

您可能也喜欢：
extjs换肤	用ExtJs制作登陆界面	Ext.apply 与 Ext.applyIf	Ext自定义LoadMask	Ex.get与Ext.fly
无觅

您可能也喜欢：
在eclipse中构建Pentaho BI Server工程	在Fedora 15 上搭建Eucalyptus	Pentaho现场支持遇到问题及解决办法	接触云服务环境Eucalyptus	OpenNebula 2.2的特性
无觅

您可能也喜欢：
kettle进行数据迁移遇到的问题	数据迁移的一些总结	java 读取图片的 Exif 数据	从Excel表格拖放数据到Ext Grid中	Struts2使用validator框架进行数据校验
无觅