OBTAINING SPRING 3 ARTIFACTS WITH MAVEN

原文：http://blog.springsource.com/2009/12/02/obtaining-spring-3-artifacts-with-maven/

A recent commentor here ragged, "It's only half of the world that's using Maven", when pointing
out it is not obvious how to obtain Spring 3 artifacts with Maven. In this entry, I'll show you how to do this and what the options are. This information will also be integrated into the reference documentation of the upcoming Spring 3 final release.

MAVEN REPOSITORIES WHERE SPRING ARTIFACTS ARE PUBLISHED

In general, Spring publishes its artifacts to two different places:

  1. Maven Central, which is the default repository Maven queries, and does not require any special configuration
    to use
  2. The Enterprise Bundle Repository (EBR), which is run by SpringSource and also hosts all the
    libraries that integrate with Spring

So the first thing you need to decide when obtaining Spring with Maven is which place you'll get it from. In general, if you care about OSGi, use the EBR, since it houses OSGi
compatible artifacts for all of Spring's dependencies, such as Hibernate and Freemarker. If OSGi does not matter to you, either place works, though there are some pros and cons between them. In general, pick one place or the other for your project;
do not mix them. This is particularly important since EBR artifacts use a different naming convention than Maven Central artifacts.

Below is a table that compares Maven Central to the EBR in several areas:

Feature Maven Central Enterprise Bundle Repository (EBR)
OSGi Compatible No Yes
Number of Artifacts Tens of thousands; all kinds Hundreds; those that Spring integrates/supports
Consistent Naming Conventions for all Artifacts? No Yes
Artifact Naming Convention Group id
Varies; newer artifacts use domain name e.g. "org.sl4j"; older artifacts use artifact id e.g. "log4j"

Artifact id
Varies; typically the JAR file name minus extension e.g. "log4j"
Version
Varies; most use numbers and dots e.g. "3.0.0"

 Group id
<Domain name> e.g. "org.springframework"
Artifact id
<Bundle-SymbolicName>, derived from main package e.g. "org.springframework.beans". If the JAR had to be patched to ensure OSGi compliance, "com.springsource." is prepended e.g. "com.springsource.org.apache.log4j"
Version
OSGi version number format of <major>.<minor>.<micro>[.qualifier] e.g. "3.0.0.RC3"
Publishing Automatic (rSync via remote repositories) Manual (JIRA processed by SpringSource)
Quality Assurance None I am aware of; Accuracy is responsibility of publishing organization Extensive (for both MANIFEST.mf and .pom); QA is performed by Spring Team
Hosting @ Contegix funded by Sonatype with several mirrors S3 funded by SpringSource
Search Utilities Various www.springsource.com/repository
Integrated with SpringSource Tools (STS, Roo, etc) Yes, with STS and Roo Yes, with STS

Now that you know the options, I'll discuss how to obtain Spring artifacts from both places.

OBTAINING SPRING RELEASES FROM MAVEN CENTRAL

You do not have to add a repository to your .pom to obtain final releases of Spring projects from Maven Central. Simply add the dependencies your project requires.

A .pom <dependency> snippet for each Spring Framework 3 artifact as it will be indexed in Maven Central is listed below.

<!-- Shared version number properties -->
<properties>
    <org.springframework.version>3.0.5.RELEASE</org.springframework.version>
</properties>
 
<!--
    Core
utilities used by other modules.
    Define
this if you use Spring Utility APIs (org.springframework.core.*/org.springframework.util.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Expression
Language (depends on spring-core)
    Define
this if you use Spring Expression APIs (org.springframework.expression.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-expression</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Bean
Factory and JavaBeans utilities (depends on spring-core)
    Define
this if you use Spring Bean APIs (org.springframework.beans.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Aspect
Oriented Programming (AOP) Framework (depends on spring-core, spring-beans)
    Define
this if you use Spring AOP APIs (org.springframework.aop.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Application
Context (depends on spring-core, spring-expression, spring-aop, spring-beans)
    This
is the central artifact for Spring's Dependency Injection Container and is generally always defined
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Various
Application Context utilities, including EhCache, JavaMail, Quartz, and Freemarker integration
    Define
this if you need any of these integrations
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Transaction
Management Abstraction (depends on spring-core, spring-beans, spring-aop, spring-context)
    Define
this if you use Spring Transactions or DAO Exception Hierarchy
    (org.springframework.transaction.*/org.springframework.dao.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    JDBC
Data Access Library (depends on spring-core, spring-beans, spring-context, spring-tx)
    Define
this if you use Spring's JdbcTemplate API (org.springframework.jdbc.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Object-to-Relation-Mapping
(ORM) integration with Hibernate, JPA, and iBatis.
    (depends
on spring-core, spring-beans, spring-context, spring-tx)
    Define
this if you need ORM (org.springframework.orm.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-orm</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Object-to-XML
Mapping (OXM) abstraction and integration with JAXB, JiBX, Castor, XStream, and XML Beans.
    (depends
on spring-core, spring-beans, spring-context)
    Define
this if you need OXM (org.springframework.oxm.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-oxm</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Web
application development utilities applicable to both Servlet and Portlet Environments
    (depends
on spring-core, spring-beans, spring-context)
    Define
this if you use Spring MVC, or wish to use Struts, JSF, or another web framework with Spring (org.springframework.web.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Spring
MVC for Servlet Environments (depends on spring-core, spring-beans, spring-context, spring-web)
    Define
this if you use Spring MVC with a Servlet Container such as Apache Tomcat (org.springframework.web.servlet.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Spring
MVC for Portlet Environments (depends on spring-core, spring-beans, spring-context, spring-web)
    Define
this if you use Spring MVC with a Portlet Container (org.springframework.web.portlet.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc-portlet</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Support
for testing Spring applications with tools such as JUnit and TestNG
    This
artifact is generally always defined with a 'test' scope for the integration testing framework and unit testing stubs
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>${org.springframework.version}</version>
  <scope>test</scope>
</dependency>

OBTAINING SPRING RELEASES FROM THE ENTERPRISE BUNDLE REPOSITORY (EBR)

To obtain final releases of Spring projects from the EBR, add the following repositories to your .pom:

<repository>
    <id>com.springsource.repository.bundles.release</id>
    <name>EBR
Spring Release Repository</name>
    <url>http://
repository.springsource.com/maven/bundles/release</url>
</repository>
<repository>
    <id>com.springsource.repository.bundles.external</id>
    <name>EBR
External Release Repository</name>
    <url>http://
repository.springsource.com/maven/bundles/external</url>
</repository>

Then simply add the dependencies your project requires, keeping in mind the EBR artifact naming conventions.

A .pom <dependency> snippet for each Spring Framework 3 artifact as it will be indexed in the EBR is listed below:

<!-- Shared version number properties -->
<properties>
    <org.springframework.version>3.0.0.RELEASE</org.springframework.version>
</properties>
 
<!--
    Core
utilities used by other modules.
    Define
this if you use Spring Utility APIs (org.springframework.core.*/org.springframework.util.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.core</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Expression
Language (depends on core)
    Define
this if you use Spring Expression APIs (org.springframework.expression.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.expression</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Bean
Factory and JavaBeans utilities (depends on core)
    Define
this if you use Spring Bean APIs (org.springframework.beans.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.beans</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Aspect
Oriented Programming (AOP) Framework (depends on core, beans)
    Define
this if you use Spring AOP APIs (org.springframework.aop.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.aop</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Application
Context (depends on core, expression, aop, beans)
    This
is the central artifact for Spring's Dependency Injection Container and is generally always defined
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.context</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Various
Application Context utilities, including EhCache, JavaMail, Quartz, and Freemarker integration
    Define
this if you need any of these integrations
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.context.support</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Transaction
Management Abstraction (depends on core, beans, aop, context)
    Define
this if you use Spring Transactions or DAO Exception Hierarchy
    (org.springframework.transaction.*/org.springframework.dao.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.transaction</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    JDBC
Data Access Library (depends on core, beans, context, transaction)
    Define
this if you use Spring's JdbcTemplate API (org.springframework.jdbc.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.jdbc</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Object-to-Relation-Mapping
(ORM) integration with Hibernate, JPA, and iBatis.
    (depends
on core, beans, context, transaction)
    Define
this if you need ORM (org.springframework.orm.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.orm</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Object-to-XML
Mapping (OXM) abstraction and integration with JAXB, JiBX, Castor, XStream, and XML Beans.
    (depends
on core, beans, context)
    Define
this if you need OXM (org.springframework.oxm.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.oxm</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Web
app development utilities common across Servlet/Portlet environments (depends on core, beans, context)
    Define
this if you use Spring MVC, or wish to use Struts, JSF, or another web framework with Spring (org.springframework.web.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.web</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Spring
MVC for Servlet Environments (depends on core, beans, context, web)
    Define
this if you use Spring MVC with a Servlet Container such as Apache Tomcat (org.springframework.web.servlet.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.web.servlet</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Spring
MVC for Portlet Environments (depends on core, beans, context, web)
    Define
this if you use Spring MVC with a Portlet Container (org.springframework.web.portlet.*)
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.web.portlet</artifactId>
  <version>${org.springframework.version}</version>
</dependency>
 
<!--
    Support
for testing Spring applications with tools such as JUnit and TestNG
    This
artifact is generally always defined with a 'test' scope for the integration testing framework and unit testing stubs
-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.test</artifactId>
  <version>${org.springframework.version}</version>
  <scope>test</scope>
</dependency>

OBTAINING SPRING MILESTONE RELEASES

Milestones and Release Candidates may not be published directly to Maven Central, and in general are published separately from final releases. SpringSource hosts two repositories for obtaining Spring milestones. The first one should be used in conjunction with
Maven Central, and the second one in conjunction with the EBR.

Obtaining Milestones from the Maven Central Compatible Repository

To obtain Spring milestones from the Maven Central compatible repository, add the following repository to your .pom:

<repository>
    <id>org.springframework.maven.milestone</id>
    <name>Maven
Central Compatible Spring Milestone Repository</name>
    <url>http://
maven.springframework.org/milestone</url>
</repository>

The milestone version number format is <major>.<minor>.<micro>.M#; for example, 3.0.0.M4. The release candidate version number format is <major>.<minor>.<micro>.RC#; for example, 3.0.0.RC3.

For example, adding the following dependency would retrieve version 3.0.0.RC3 of the spring-context artifact:

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>3.0.0.RC3</version>
</dependency>

Obtaining Milestones from the Enterprise Bundle Repository (EBR)

To obtain Spring milestones from the EBR, add the following repository to your .pom:

<repository>
    <id>com.springsource.repository.bundles.milestone</id>
    <name>EBR
Spring Milestone Repository</name>
    <url>http://
repository.springsource.com/maven/bundles/milestone</url>
</repository>

Be sure to keep in mind the distinct EBR artifact naming convention. For example, adding the following dependency would retrieve version 3.0.0.RC3 of the org.springframework.context artifact:

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.context</artifactId>
  <version>3.0.0.RC3</version>
</dependency>

OBTAINING NIGHTLY SPRING SNAPSHOTS

Snapshots of Spring projects are published each night, allowing users to verify that reported issues have been resolved before the next release. Like Milestones, there is a separate Maven Central compatible snapshot repository and an EBR snapshot repository.

Obtaining Snapshots from the Maven Central Compatible Repository

To obtain Spring nightly snapshots from the Maven Central compatible repository, add the following repository to your .pom:

<repository>
    <id>org.springframework.maven.snapshot</id>
    <name>Maven
Central Compatible Spring Snapshot Repository</name>
    <url>http://
maven.springframework.org/snapshot</url>
</repository>

The snapshot version format is <major>.<minor>.<micro>.BUILD-SNAPSHOT; for example, 3.0.1.BUILD-SNAPSHOT.

For example, adding the following dependency would retrieve the latest snapshot of the spring-context artifact:

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>3.0.1.BUILD-SNAPSHOT</version>
</dependency>

Notice the <major>.<minor>.<micro>.BUILD-SNAPSHOT format differs slightly from the traditional Maven 2 snapshot format of <major>.<minor>.<micro>-SNAPSHOT. This is because x.y.z-SNAPSHOT is not a valid OSGi version number. All Spring projects now follow the OSGi
version numbering scheme (Maven 3 will as well).

Obtaining Snapshots from the Enterprise Bundle Repository (EBR)

To obtain Spring nightly snapshots from the EBR, add the following repository to your .pom:

<repository>
    <id>com.springsource.repository.bundles.snapshot</id>
    <name>EBR
Spring Snapshot Repository</name>
    <url>http://
repository.springsource.com/maven/bundles/snapshot</url>
</repository>

As an final example, adding the following dependency would retrieve the latest snapshot of the org.springframework.context artifact:

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>org.springframework.context</artifactId>
  <version>3.0.1.BUILD-SNAPSHOT</version>
</dependency>

SPRING PROJECT PRODUCTIVITY TOOLS

I would like to close with a brief note about the tooling Spring provides for projects that use Maven. Both the SpringSource Tool Suite and Spring Roo provide
wizards that can generate new Spring projects with pre-configured .poms. Roo goes quite far in this regard–it can actually manage your .pom for you as you execute code generation commands that require additional artifacts to be downloaded.

Cloud Foundry also has a new capability that allows cloud deployments to be made sans external dependencies, greatly reducing deployment times. To make this work, Cloud Foundry syncs with the EBR after publishing to complete a deployment.

SUMMARY

Whew, that was quite a lot of ground to cover.

This was a long entry, but in summary, I hope it is now clear how to obtain Spring artifacts with Maven, whether you are seeking a final release, a milestone, a release candidate, or a nightly snapshot. Making Spring easy to get your hands on is very important
to us. It's particularly important in a project's milestone phase, when users are trying out new functionality for the first time and have the opportunity to directly influence Spring's direction.

SIMILAR POSTS

时间： 2024-08-30 09:02:29

OBTAINING SPRING 3 ARTIFACTS WITH MAVEN的相关文章

Spring整合MyBatis（Maven+MySQL）图文教程详解_java

一. 使用Maven创建一个Web项目 为了完成Spring4.x与MyBatis3.X的整合更加顺利,先回顾在Maven环境下创建Web项目并使用MyBatis3.X,第一.二点内容多数是回顾过去的内容 . 1.2.点击"File"->"New"->"Other"->输入"Maven",新建一个"Maven Project",如下图所示: 1.2.请勾选"Create a si

spring mvc-Spring mvc+mybatis+maven的项目tomcat启动的时候，控制台不输出xml文件的加载信息

问题描述 Spring mvc+mybatis+maven的项目tomcat启动的时候,控制台不输出xml文件的加载信息 2014-3-17 9:52:18 org.apache.catalina.core.AprLifecycleListener init信息: Loaded APR based Apache Tomcat Native library 1.1.24 using APR version 1.4.6.2014-3-17 9:52:18 org.apache.catalina.co

spring mvc-在Eclipse中使用Maven+Spring mvc +cxf搭建Web Service

问题描述 在Eclipse中使用Maven+Spring mvc +cxf搭建Web Service 请各路大神给出详细步骤,包括项目怎么建.各种配置文件怎么配.Java类里面怎么写(可以是一个简单的hello world)等等,最好有截图,非常感谢!

spring mvc-Spring mvc工程maven编译,报错。

问题描述 Spring mvc工程maven编译,报错. Failed to load class "org.slf4j.impl.StaticLoggerBinder 这是我的Pom.xml文件配置 <!-- log4j --> log4j log4j 1.2.8 <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId>

【maven + hibernate(注解) +spring +springMVC】 使用maven搭建项目

研究,百度,查资料+好友帮助,使用MyEcplise2015工具,通过maven搭建hibernate+springMVC+spring的项目,数据库采用MySql5.5 不过使用的版本会在项目搭建过程中介绍. 大概就是下面的几个步骤: 1. 设计数据库,得到数据库 2.使用maven搭建项目,导入包的依赖 3.引入spring的配置信息,放在资源文件中 4.引入Log4j日志文件配置 5.配置hibernate 6.配置ehcache.xml 7.使用hibernate  tools生成实体

springframework maven地址

http://blog.springsource.com/2009/12/02/obtaining-spring-3-artifacts-with-maven/ A .pom <dependency> snippet for each Spring Framework 3 artifact as it will be indexed in Maven Central is listed below. 001 <!-- Shared version number properties --

spring boot集成mongodb最简单版

通过spring tools suite新建一个spring project.带maven的即可 pom.xml文件配置 001 <?xml version="1.0" encoding="UTF-8"?> 002 <project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance&

通向架构师的道路 第二十一天 万能框架spring(三)之SSH

一.前言 我们有了Spring+JdbcTemplate和Spring+iBatis并结合maven的基础,搭建一个SSX这样的框架现在就和玩一 样的简单了,今天我们将搭建一个使用Struts1.3,Srping3, Hibernate3的SSH1的开发框架,大家跟着我一步步走,会发觉在程 序跑通后自己再动手搭建一遍这个框架,只需要30分钟. 二.SSH框架 仔细看这个框架,稍微有点不一样了. 1) Spring3是通过一个hibernate template来和hibernate的dao层结合

spring boot应用启动原理分析

spring boot quick start 在spring boot里,很吸引人的一个特性是可以直接把应用打包成为一个jar/war,然后这个jar/war是可以直接启动的,不需要另外配置一个Web Server. 如果之前没有使用过spring boot可以通过下面的demo来感受下. 下面以这个工程为例,演示如何启动Spring boot项目: git clone git@github.com:hengyunabc/spring-boot-demo.git mvn spring-boot