appendix A:
Seam starter set
This appendix explores the set of libraries and tools you need to develop with
Seam. Seam consists of just a handful of JAR files, listed in section A.2.1. Once these
libraries are added to your application’s classpath, they open the door to a wealth
of integrations and a consistent programming model. To get started with Seam, you
can create a new project using seam-gen (see chapter 2), adopt an example application
from the Seam distribution, or add the Seam libraries to an existing project by
mining the JAR files from the Seam distribution or registering the Seam modules as
Maven 2 or Ivy dependencies.
本附录浏览你要用于SEAM开发的库和工具集。SEAM就是由一堆JAR文件组成。一旦这些库放到你应用的类路径。就可以使用这集成统一的编程模型了。开始SEAM之旅时,可以先用seam-gen来看看发布包中的例子程序。或者将JAR文件加到现存的项目,或者将模型注册为Maven 2 or Ivy dependencies.
Given that Seam is often described as an “integration framework,” you’d expect
it to rely on a wide variety of external libraries. While that’s true, it’s nothing to get
worried about. Both the Seam distribution and the Maven 2 configuration provided
by Seam include compatible libraries that are verified to work with a given
Seam version. Thus, Seam truly lives up to its title as an integration framework,
both at the API and distribution levels.
作为集成框架,你会期望其依赖于广泛的外部库。发布包和Maven 2配置文件会因版本而不同。
Before swinging away, you need to check the prerequisites for using Seam and
the seam-gen tool, which extend beyond just extracting the Seam distribution on
your hard drive.
A.1 Stepping through the prerequisites
Chapter 2 makes the recommendation of using seam-gen as your first step into
Seam. Thus, the prerequisites presented in this section are geared toward using
seam-gen to create and deploy the database-oriented application that accompanies
this book. Let’s have a look at what software is needed to follow along with the tutorial
in chapter 2:
必要条件
第二章建议用seam-gen作为进入SEAM世界的第一步,因此这里所说的是建立和部署本书随附的基于数据库的应用的前提条件。这面是第二章所要用到的软件。
■ Java SE (JDK) (5.0 or greater) from Sun, IBM, BEA, Apple, or RedHat (IcedTea)
■ JBoss Application Server (4.2 or greater)
■ JBoss Seam (2.0 or greater)
■ A database and JDBC driver (the book source code uses the H2 database)
■ Seam in Action source code (needed for the database schema and seed data)
While you can get by using the seam-gen tool with the software listed here, you may
find the following optional dependencies valuable as well:
■ Apache Ant (1.7.0 or greater)
■ Alternate application server (GlassFish Application Server V2 or greater)
I’ll step through each of these prerequisites in turn. Any time you see a reference to
/home/twoputt, replace it with the location of your software development directory.
The folders under this directory referenced in this appendix are consistent with the
book’s source code and are described further in the introduction. Don’t get too
worked up over the JBoss AS requirement. It just happens to be the application server
supported by seam-gen out of the box. Any Java EE application server can stand in its
place. Java 5 is required, which hopefully will not turn you off Seam if you’re still using
Java 1.4 or lower. I begin with the reasoning behind the Java 5 requirement.
每次见到/home/twoputt,就替换成你的软件开发目录。
A.1.1 Java 5 compliance
A Java 5–compliant JDK (Java SE Development Kit) is required to develop Seam
applications, and the applications must be run under a Java 5–compliant JVM (Java
virtual machine). It’s also strongly recommended that applications be deployed to a
Java EE 5–compliant application server. This recommendation becomes a requirement
if you want to take advantage of Seam’s EJB 3 integration.
因为如果你要利用EJB 3集成,你就该用Java 5。
The dependency on Java SE 5 and Java EE 5 accounts for a large part of Seam’s success
and works to your advantage. Instead of having to tiptoe around the enhancements that
came with the release of Java 5, as some other frameworks do, Seam embraces annotations
and generics to eliminate unnecessary XML configuration and ugly casting. Seam
is sending the message to the industry that it’s time to move on. The productivity gains
afforded by using a Java 5–compliant language are too valuable to put off any longer.
Although it may be possible to use a tool like Retrotranslator1 to port a Seam application
to a J2SE 1.4 JVM, it still doesn’t eliminate the requirement of using a Java 5–compliant
JDK for development, nor does it get you any closer to using EJB 3.
SEAM尽量使用annotations而减少XML
If you haven’t yet moved to JDK 5 (or better), you’ll need to download it from the
vendor of your choice. I recommend using Sun’s JDK 6 since, in my gut-feeling tests,
it’s the fastest JVM for development. Once you’ve downloaded the Java distribution,
you need to add the java binary to your PATH environment variable. It’s also good
practice to set the JAVA_HOME environment variable to point to the extracted Java distribution,
as some tools rely on it. Here are the shell commands (for Linux and Mac
OS X) for setting these variables:
有JDK 6最好,这是现在最快的JVM。
export JAVA_HOME=/home/twoputt/opt/jdk1.6.0_03
export PATH=$JAVA_HOME/bin:$PATH
If you’re using Debian/Ubuntu Linux, it’s even easier. You simply type sudo apt-get
install sun-java6-jdk and the Sun Java distribution is downloaded from the multiverse
apt repository and configured for you. This channel is available since Java has
finally been released under a distributable license.2 Other Linux distributions offer
similar packages. Mac OS X 10.5 (Leopard) is distributed with Java 5 and it’s already
available in the default PATH. If you’re on Windows, I strongly recommend using Cygwin
or a VMWare image of Linux.
如果你用的是windows,则我推荐使用Cygwin或VMWare的Linux虚机。
Your next stop is the JBoss labs, where you’ll pick up the JBoss Application Server
(JBoss AS). Following that, I discuss two alternate servers: GlassFish and Tomcat.
A.1.2 Java EE 5 application servers
Seam is designed to make the standard Java EE 5 services more accessible, not to reinvent
them. Throughout this book, I emphasize why deploying to a Java EE 5 application
server is a “Good Thing.” You may be inclined to assume that Tomcat, JBoss AS
without EJB 3, and integration tests are left out in the cold. This is not the case. Seam
applications just fit more naturally in a Java EE 5 environment. Rest assured that the
Embedded JBoss runtime can be added to the classpath of a non–Java EE environment
to “enlighten” it with Java EE 5 capabilities. It’s also possible to configure a Seam application
to run in a Java SE environment, independent of any Java EE 5 features. For
instance, you can use resource-local transactions and an application-managed persistence
manager as alternatives. But to get going quickly, you’ll find that using JBoss AS
is the most convenient option.
设计SEAM是为了标准Java EE 5更容易使用,而不是要重发明它。如果你更倾向于Tomcat,则就别玩儿集成测试了。想快速开发,JBoss AS还是最好的选择。
JBOSS APPLICATION SERVER
You can download the JBoss Application Server (AS) from its project page in the JBoss
labs: http://labs.jboss.org/jbossas. You’ll be directed to the SourceForge.net site, where
you can download the zip file. The recommended version of JBoss AS to use with Seam
2.0.x is 4.2.2.GA.3 After the download completes, extract the archive into the opt folder
in your home directory. The location of the extracted archive is referenced as the placeholder
${jboss.home} in chapter 2. Chapter 2 also provides instructions on how to start
JBoss AS. Recall that you must run the application server using a Java 5–compliant JVM.
If you plan on accessing the server from another computer, you need to add the -b
0.0.0.0 argument to the run command. This tells the server to accept connections
from all IP addresses. The default is to only allow local connections.
如果要从其它计算机访问服务器,则要有run命令中加入-b 0.0.0.0。表示接受所有IP的连接。
The 4.2.x series of JBoss AS is a partial implementation of Java EE 5, with support
for EJB 3, allowing you to take advantage of all of Seam’s features. I encourage you to
move to JBoss AS 5 when it’s finalized to get all the Java EE 5 features. The benefit of
using a Java EE 5 environment is discussed in the remainder of this section.
4.2是对Java EE 5的部分实现,支持EJB3。JBoss AS 5则已有了Java EE 5的所有特性。
No love for JBoss?
I expect that some of you will grumble about the required JBoss AS download. Perhaps
you fear vendor lock-in or find the hefty 100 MB-plus download painful. You can
unfold your arms and put your hands back on the keyboard. JBoss AS is not required
to use Seam. However, having it around makes getting started a heck of a lot easier
since JBoss AS is the target application server for projects created by seam-gen. Remember,
sticking with the defaults cuts down on work—and hassle.
ALTERNATE APPLICATION SERVERS
If you’re developing an off-the-shelf application, it’s important to test it on alternate
application servers to ensure portability. Covering the interoperability of Seam applications
among different application servers here would duplicate the focused effort
done by the Seam development team and logged in the Seam reference documentation.
Although theoretically Seam can run on any Java EE application server, the officially
tested platforms are JBoss AS 4.2, IBM WebSphere 6.1, WebLogic 10, GlassFish
version 2, Oracle OC4J 11g, and Tomcat 5 and 6. I want to contrast two of the options,
GlassFish and Tomcat, to help you put the choice of where to deploy a Seam application
in perspective.
GLASSFISH
One of the application servers to which I am partial is GlassFish,4 the open source Java
EE 5–compliant server sponsored by Sun Microsystems. It’s the reference implementation
for Java EE–compliant servers and passes the Java EE 5 Technology Compatibility
Kit (TCK) 100 percent, unlike JBoss 4.2. It also sports an attractive and intuitive administration
console, making it user-friendly and easy to adopt.
这是Sun的应用服务器。对Java EE 5百分之百支持。还有管理控制方便使用。
I put strong emphasis on the word compliant in the last paragraph. What’s so great
about compliance? It’s about the rule of least surprise. If every application server had
its own set of guidelines, then moving your application from one server to another
would require a lot of reconfiguring in the best-case scenario. If the services provided
by a server behave differently or don’t line up, the changes might even be more drastic,
perhaps requiring you to modify your code. Any work spent making such changes
provides zero value to your application and is pure overhead from a monetary standpoint,
definitely something you want to avoid. That brings us to Tomcat, which is
many miles from being compliant.
TOMCAT
Once upon a time, the industry flocked to Tomcat while fleeing a bad relationship
with J2EE application servers. Developers wrote them off because they were expensive,
slow, and heavyweight, and led to vendor lock-in. Tomcat represented the grassroots
movement and let developers feel more free. Today, Tomcat is the most widely used
“application server.”5
很多开发者放弃使用其它J2EE服务器是这为他们贵、慢、大、商业圈套,Tomcat作为草根服务器,让开发者或轻松。
The main problem with Tomcat is that it isn’t a Java EE–compliant application
server—it’s a servlet container. Although it made sense to cut corners at the time
when J2EE servers had grown fat and expensive, times have changed. The Java EE 5
application servers have escaped their legacy and are now fast and cheap (GlassFish,
for instance, is open source and starts in under a second). Furthermore, application
servers adhere to a stack of successful and progressive specifications and offer all the
services that you need to support transactional applications right out of the box. In my
opinion, Java EE application servers offer a much better development experience than
a servlet container like Tomcat.
主要问题是只是个servlet容器,对J2EE不全面支持。而J2EE服务器本身也已去除了原有的贵、大、慢等问题。
You can even argue that Tomcat is now the culprit of vendor lock-in. It requires you
to bend your application over backward to get it to work in this nonstandard environment,
whereas all other application servers can theoretically share applications with
little effort. That’s why the preferred solution for deploying an application that uses
EJB 3 or JTA to Tomcat is to make Tomcat act like a Java EE 5 application server rather
than forcing the application to fit Tomcat’s expectations. In this scenario, Seam 2.0
relies on Embedded JBoss to be configured directly in the Tomcat container (a change
from packaging the Embedded EJB 3 runtime in the application, the strategy used in
Seam 1.2). You can find instructions for setting up Embedded JBoss on Tomcat in the
Seam reference documentation.
你的应用必须做一些修改和让步才能使用TOMCAT。
It’s certainly possible to deploy Seam applications to a vanilla Tomcat installation.
However, you have to either change the application so that it doesn’t rely on container-
provided services such as JCA and JTA, or you need to register these services
using Tomcat’s proprietary configuration descriptors. Either way, EJB 3 gets tossed out
the window. Are you starting to see why I claim that servlet containers are more proprietary,
and more of a hassle, than a Java EE–complaint application server? My advice
is to rethink why you are considering Tomcat.
A.1.3 Absent (JavaServer) Faces
As you know, Seam uses JavaServer Faces (JSF) as the preferred user interface (UI)
framework. Thus, you may be wondering why JSF isn’t listed as a dependency. Once
again, Seam applications are intended to be deployed to a Java EE 5–compliant application
server and since JSF 1.2 is a part of Java EE 5, it’s already available. If you aren’t
using a standard Java EE 5 environment, you need to download JSF and package it with
your application. You should grab a JSF 1.2–compliant implementation, which is
required by Seam’s JSF support.
你可能会奇怪为什么JSF没有列为必需。因为JSF已是Java EE 5中的标准。
Seam developers recommend the Sun implementation of JSF (Mojarra) over
Apache MyFaces. The reason for this preference is that Sun’s implementation has succeeded
in keeping up with the latest JSF specification and because it too is an open
source project. Both JBoss AS and GlassFish now bundle the Sun implementation in
their respective application servers. Despite this move, I’m sure this is not the last we’ll
hear of this debate.
建议使用SUN的JSF而不是Apache MyFaces,因为其实现了最新的标准。
With your deployment environment ready, it’s finally time to grab Seam and the
example source code so that you are ready to go through the tutorial in chapter 2.
A.2 Downloading the Seam distribution
You can download the latest version of the Seam 2.0 distribution from the Seam project
page in the JBoss labs: http://labs.jboss.org/jbossseam. Feel free to upgrade as new
versions become available, but know that this book’s source code is developed for
Seam 2.0.3.GA. Extract the Seam distribution archive into the opt folder in your home
directory. The location of the extracted archive is referred to as the Seam distribution
directory throughout this book.
Why is the Seam distribution so large?
You may consider the Seam distribution to be unnecessarily large (greater than 100
MB) and for this reason conclude that Seam is bloated. The reality is that the Seam
JAR files amount to less than 2 MB. The distribution is large for the benefit of the
developer. It contains all of the source code, seam-gen, the reference documentation,
dependent JAR files, and 30-plus examples. You can always get the essential
artifacts from the JBoss Maven 2 repository.6
发布包很大是为了方便开发者而包含了所有开发代码、seam-gen、参考文档、依赖的JAR及30个以上的例子。SEAM本身中有不到2M。
A.2.1 Seam’s modules
Seam 2.0 consists of seven JAR files, each representing one Seam module. Table A.1 lists
the artifact ID of each module and its purpose. The JAR files, whose names are derived
by appending .jar to the artifact ID, are found in the lib folder of the Seam distribution.
Seam 2.0由7个模块组成。
Take note that the presence of the Seam debug module on the classpath activates hot
deployment of components and the Seam development pages. I recommend that you
remove this module from the classpath when deploying to production.
注:
debug模块是为了激活热部署,建议发布产品时去除此项。
A.2.2 A wealth of documentation and examples
Second to this book (sorry, I’m biased), the best resource you have for using Seam is
the Seam reference documentation, which weighs in at 500-plus pages. We always
want documentation to be better, but my feeling is that the Seam developers have
done a great job of documenting Seam, especially in the area of application server
interoperability. In fact, there are several places in this book where I point you to the
reference documentation because, for certain topics, it will always provide the most
updated information.
文档和例子的价值
除了本书之外(原谅我自卖自夸),最好的资源是SEAM本身的参考文档。SEAM的文档很出色,我一直推荐在一些章节要去参考文档,因为那里总是有最新的更新。
The reference documentation can be found in both HTML and PDF format on the
Seam project page. To ensure that you always have the resources you need, keep the
PDF of the Seam documentation and the eBook of Seam in Action on your hard drive
at all times. If you’ve exhausted these resources and are still looking for more information,
consult the Seam in Action link feed, http://del.icio.us/seaminaction.
The Seam distribution includes a plethora of example applications. Although this
book has its own example application, the examples in the Seam distribution give you
additional exposure to how Seam is used. They also exercise many different deployment
environments. To deploy an example, you must specify the location of the target
application server in the build.properties file at the root of the Seam distribution
using either the jboss.home or tomcat.home property. I encourage you to explore the
example applications early on because they’ll give you context when you read about
the features of Seam in this book.
虽然本书有例子,但SEAM的例子会给你更多人展现。可部署到更多的环境。
A.2.3 Finding seam-gen amid the noise
The seam-gen tool is easily lost within the busy root folder of the Seam distribution. The
tool consists of two parts: the seam-gen script and the template folder. Unless you’re
planning to customize seam-gen, you’re likely only interested in the seam-gen script. On
Unix (or Cygwin), the script is named seam, and on Windows it’s named seam.bat.
这个工具包含两部分:脚本和模板。
To use seam-gen, you must navigate to the root of the Seam distribution directory.
Before you can run the seam-gen script on Unix, you have to make it executable. To
do that, execute chmod 755 seam (or chmod +x seam). When you run the seam script in
Unix, you always prefix the shell command with a dot followed by a forward slash,
./seam, to let the shell know that the script is in the current directory. To run the
script on Windows, you simply type seam. Following the script name, you enter the
seam-gen command to execute.
You are now ready to begin using seam-gen. The next section covers a couple more
resources that are useful for running the example application in this book.
A.3 seam-gen and the Open 18 example application
The example application used in this book is titled Open 18. It’s a golf directory and
community site. It begins its life as a seam-gen CRUD application and is customized
throughout the book. Several additional applications are also provided.
本书用的例子是Open 18。是个高尔夫的目录和社区站点。从seam-gen CRUD命令中诞生,在全书中不断完善。
A.3.1 The source code
This book’s source code can be downloaded or checked out from the SVN repository
of the Google Code project: http://code.google.com/p/seaminaction. The source
code is organized in stages so that you can pick up with the application anywhere in
the book by using the result from the previous chapter. However, you should also be
able to get there without using the source code. You can find more information on
the project page about how the source code is organized and how to build the staged
projects. You can also find instructions on how to modify a seam-gen project so that it
can be deployed to GlassFish.
Chapter 2 walks you through creating the initial application by reverse-engineering
an H2 database, which you’ll need to set up to follow along with the tutorial.
Instructions for building the database are provided in the download. Note that all of
the example applications for the book use the H2 database for persistent storage.
第二章教你用H2数据库的逆向工程的方法建立一个初始应用。要跟着下载包中的教程建立数据库。本书中所有例子都使用H2数据库来存储。
A.3.2 H2 database
The seam-gen tool specializes in setting up database-oriented applications. Thus, in
chapter 2, you feed it an H2 database to get started. H2 is a SQL database written
entirely in Java. It’s much faster than other low-end databases for reasons cited on the
H2 project website. H2 is the successor of the HSQL Database Engine (HSQLDB), both
developed by Thomas Mueller.
H2是纯JAVA编写的SQL数据库。是HSQL的传人,Thomas Mueller的杰作。
The example application leverages H2’s embedded mode, which allows the database
to be bootstrapped directly from the file system. One major limitation of using
embedded mode is that the database files can only be accessed by one JVM at a time.
To avoid locking errors, you may want to consider using client-server mode, which
allows several processes to connect to it over TCP/IP (or SSL/TLS over TCP/IP for
improved security). Another option to circumvent locking problems is to add the flag
FILE_LOCK=no to the JDBC URL, which disables H2’s file locking. Beware that if you disable
locking, you risk corruption of the database if writes occur from more than one
client. For more information about client-server mode and the H2 database in general,
visit the H2 project website: http://h2database.com.
例子应用使用了H2的嵌入模式。允许数据库从文件系统直接启动。这模式不利的地方是一次只能由一个JVM访问。为了避免锁定错误,你可能会使用C/S模式,其允许几个过程通过TCP/IP链接到它。另一个防范是在JDBC URL中使用FILE_LOCK=no标志,这将取消H2文件的锁定。取消锁定会有多客户同时访问而产生冲突的风险。
The H2 JAR file is bundled with the source code. You can also download it from the
H2 project website. The tutorial in chapter 2 assumes that it resides in the lib folder
in your home directory. seam-gen takes it from there and installs it into the JBoss
AS domain.
H2 JAR文件已包含在了源码中。第二章的指导假定库文件位于home目录的lib文件夹。seam-gen从此文件夹中取出并安装到JBoss的域中。
A.3.3 Apache Ant, turning the wheels of seam-gen
As chapter 2 explains, the workhorse behind seam-gen is Apache Ant. While you don’t
need Ant to run seam-gen, you need Ant to execute the build in a project that seamgen
creates.
seam-gen使用的是ant。你不需要ant运行seam-gen,但要用它来执行seam gen建立的项目。
You can download Ant from the Apache Ant project site: http://ant.apache.org.
The recommended version is 1.7.0. Extract the Ant distribution into the opt folder in
your home directory. You’ll also need to add the ant binary to your PATH environment
variable:
export PATH=/home/twoputt/opt/apache-ant-1.7.0/bin:$PATH
Once again, if you’re using Debian/Ubuntu Linux, you can simply type sudo apt-get
install ant to have Ant installed and configured for you automatically. Mac OS X 10.5
(Leopard) is distributed with Ant 1.7 and it’s already available in the default PATH.
A.3.4 RichFaces or ICEfaces—take your pick
The seam-gen tool offers a choice of using either RichFaces or ICEfaces to build the user
interface. Both libraries, covered in depth in chapter 12, are extensions to JSF that provide
Ajax-based interactivity, an elegant look and feel, and rich UI components. By using
either one, you eliminate a lot of custom CSS, graphics, and JavaScript that would otherwise
have to be developed and maintained as part of your application. This abstraction
and shift of responsibility is the whole value proposition of JSF components.
seam-gen提供了两个UI界面,都在第12章细述。是JSF的AJAX扩展。
So how do you configure one or the other? That’s the good news. If you use seamgen
to create your project, you just need to answer “y” or “n” in response to the question
“Do you want to use ICEfaces instead of RichFaces?” when you run seam setup.
The appropriate JAR files and configurations are then used. If you’re using ICEfaces,
you can optionally provide a local directory as an override.
A.4 Managing libraries in a seam-gen project
Both the structure and build of a seam-gen project are rather eclectic. On the one
hand, this is justifiable because it’s optimized for the most efficient turnaround during
development. On the other hand, it’s atypical build requires some explanation of
how libraries are managed.
在项目中管理库
又在呻诗了。。。
In a seam-gen project, libraries are stored in the lib folder at the root of the project.
All libraries in this folder are included on the compile classpath. Which libraries
are selected to be packaged with the deployment archive is controlled by the
deployed-jars.list file at the root of WAR projects (split up as deployed-jars-war.list and
deployed-jars-ear.list files in EAR projects). Each entry in this file, one per line, corresponds
to the name of a JAR file in the lib folder to be packaged. You can use an asterisk
character (*) for wildcard matching.
seam-gen生成的项目,库存储在根目录的lib文件夹,文件夹中的所有库会加到编译路径。要包含进发布包的文件列表在WAR项目的deployed-jars.list中,EAR项目分成deployed-jars-war.list和deployed-jars-ear.list。
To add a new JAR file to the project, you first add it to the lib folder. To have it
packaged, you append it to the deployed JARs file. That still leaves the IDEs in the
dark. You need to point the IDE at the JAR file and tell it to add the JAR to the classpath.
In Eclipse, right-click on the JAR file in the Project Navigator and select Build
Path > Add to Build Path. In NetBeans, select Project Properties and add the library to
each classpath in the Java Source Classpath panel (NetBeans differentiates between
src/model, src/action, and src/test).
要将JAR加下项目中,首先是要将库加到文件夹。但IDE对此一无所知,你应指明JAR的位置,在Eclipse中,在Project Navigator中右击JAR文件,Build Path > Add to Build Path,
If this configuration isn’t appealing, you can add Seam to a standard Maven 2 project.
如果配置文件没有appealing,你可以将SEAM加入标准的Maven 2项目。
A.5 Adding Seam as a Maven 2 dependency
If you’re only interested in the bare minimum of what you need to use Seam, or you
want to add Seam to an existing build, pulling the artifacts from the JBoss Maven 2
repository is your best bet. But using the Maven 2 artifacts doesn’t mean you have to
use Maven 2 as the build tool. Other tools, such as Ant, can also take advantage of the
artifacts in the Maven 2 repository. You can point Ant at the Maven 2 repository using
either the Maven 2 Ant tasks or Ivy. This section introduces the Seam artifacts in the
JBoss Maven 2 repository by showing you how to add them to a Maven 2 build.
如果你想得到最小的SEAM配置,或想将SEAM加入到一个已存在的项目,则应使用JBoss Maven 2库的宝贝。但这不表示要使用Maven 2的build工具。其它工具如ANT也可以利用Maven 2的库,你或者使用ANT或者Ivy。
A Maven 2 dependency follows the convention groupId:artifactId:version. The Seam
artifacts are classified under the org.jboss.seam group ID. The artifact IDs were listed
in table A.1. If you always want to use the recommended library versions with Seam,
declare the Seam root artifact as the parent in your project’s pom.xml as follows:
Using the Seam root Maven 2 POM precludes the need to declare the JBoss repository
or any versions of Seam artifacts a
来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/21802202/viewspace-1027645/,如需转载,请注明出处,否则将追究法律责任。
转载于:http://blog.itpub.net/21802202/viewspace-1027645/