登录以解锁更多InfoQ新功能
获取更新并接收通知
给您喜爱的内容点赞
关注您喜爱的编辑与同行
966,690 十月 独立访问用户
语言 & 开发
架构 & 设计
文化 & 方法
您目前处于：
Spring 4支持的Java 8新特性一览
Spring 4支持的Java 8新特性一览
Adib Saikali
0&他的粉丝
0&他的粉丝
日. 估计阅读时间:
：Facebook、Snapchat、Tumblr等背后的核心技术
亲爱的读者：我们最近添加了一些个人消息定制功能，您只需选择感兴趣的技术主题，即可获取重要资讯的。
相关厂商内容
相关赞助商
Java 8的设计者想保证它是向下兼容的，以使其lambda表达式能在旧版本的代码编译器中使用。向下兼容通过定义函数式接口概念实现。
基本上，Java 8的设计者分析了现有的Java代码体系，注意到很多Java程序员用只有一个方法的接口来表示方法的思想。以下就是JDK和Spring中只有一个方法的接口的例子，也就是所谓的&函数式接口&。
JDK里的函数式接口：
public interface Runnable {
public abstract void run();}
public interface Comparable&T& {
public int compareTo(T o);}
Spring框架里的函数式接口：
public interface ConnectionCallback&T& {
T doInConnection(Connection con) throws SQLException, DataAccessE}
public interface RowMapper&T&{
T mapRow(ResultSet rs, int rowNum) throws SQLE}
在Java 8里，任何函数式接口作为方法的参数传入或者作为方法返回值的场合，都可以用lambda表达式代替。例如，Spring的JdbcTemplate类里有一个方法定义如下：
public &T& List&T& query(String sql, RowMapper&T& rowMapper)
throws DataAccessException
这个查询方法的第二个参数需要RowMapper接口的一个实例。在Java 8中我们可以写一个lambda表达式作为第二个参数的值传进去。
别把代码写成这样：
jdbcTemplate.query(&SELECT * from products&, new RowMapper&Product&(){
public Product mapRow(ResultSet rs, int rowNum) throws SQLException {
Integer id = rs.getInt(&id&);
String description = rs.getString(&description&);
Integer quantity = rs.getInt(&quantity&);
BigDecimal price = rs.getBigDecimal(&price&);
Date availability = rs.getDate(&available_date&);
Product product = new Product();
product.setId(id);
product.setDescription(description);
product.setQuantity(quantity);
product.setPrice(price);
product.setAvailability(availability);
我们这么写：
jdbcTemplate.query(&SELECT * from queries.products&, (rs, rowNum) -& {
Integer id = rs.getInt(&id&);
String description = rs.getString(&description&);
Integer quantity = rs.getInt(&quantity&);
BigDecimal price = rs.getBigDecimal(&price&);
Date availability = rs.getDate(&available_date&);
Product product = new Product();
product.setId(id);
product.setDescription(description);
product.setQuantity(quantity);
product.setPrice(price);
product.setAvailability(availability);
我们注意到Java 8中这段代码使用了lambda表达式，这比之前的版本中使用匿名内部类的方式紧凑、简洁得多。
涵盖Java 8中函数式接口的所有细节超出了本文的范畴，我们强烈建议您从详细学习函数式接口。本文想要传达的关键点在于Java 8的lambda表达式能传到那些用Java 7或更早的JDK编译的、接受函数式接口作为参数的方法中。
Spring的代码里有很多函数式接口，因此lambda表达式很容易与Spring结合使用。即便Spring框架本身被编译成Java 6的.class文件格式，你仍然可以用Java 8的lambda表达式编写应用代码、用Java 8编译器编译、并且在Java 8虚拟机上运行，你的应用可以正常工作。
总之，因为Spring框架早在Java 8正式给函数式接口下定义之前就已经实际使用了函数式接口，因此在Spring里使用lambda表达式非常容易。
Spring 4和Java 8的时间与日期API
Java开发者们一直痛恨java.util.Date类的设计缺陷，终于，Java 8带来了全新的日期与时间API，解决了那些久被诟病的问题。这个新的日期与时间API值得用的篇幅来讲述，因此我们在本文不会详述其细节，而是重点关注新的java.time包中引入的众多新类，如LocalDate、LocalTime和 LocalDateTime。
Spring有一个数据转换框架，它可以使字符串和Java数据类型相互转换。Spring 4升级了这个转换框架以支持Java 8日期与时间API里的那些类。因此你的代码可以这样写：
@RestController
public class ExampleController {
@RequestMapping(&/date/{localDate}&)
public String get(@DateTimeFormat(iso = ISO.DATE) LocalDate localDate)
return localDate.toString();
上面的例子中，get方法的参数是Java 8的LocalDate类型，Spring 4能接受一个字符串参数例如并将它转换成Java 8 LocalDate的实例。
要注意的是Spring通常会与其它一些库一起使用实现特定功能，比如与Hibernate一起实现数据持久化，与Jackson一起实现Java对象和JSON的互相转换。
虽然Spring 4支持Java 8的日期与时间库，这并不表示第三方框架如Hibernate和Jackson等也能支持它。到本文发表时，Hibernate JIRA里仍有一个开放状态的请求要求在Hibernate里支持Java 8日期与时间API。
Spring 4与重复注解
Java 8增加了对重复注解的支持，Spring 4也同样支持。特殊的是，Spring 4支持对注解@Scheduled和@PropertySource的重复。例如，请注意如下代码片段中对@PropertySource注解的重复使用：
@Configuration
@ComponentScan
@EnableAutoConfiguration
@PropertySource(&classpath:/example1.properties&)
@PropertySource(&classpath:/example2.properties&)public class Application {
@Autowired
public JdbcTemplate template(DataSource datasource) {
System.out.println(env.getProperty(&test.prop1&));
System.out.println(env.getProperty(&test.prop2&));
return new JdbcTemplate(datasource);
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
Java 8的Optional&&与Spring 4.1
忘记检查空值引用是应用代码中一类常见的bug来源。消除NullPointerExceptions的方式之一是确保方法总是返回一个非空值。例如如下方法：
public interface CustomerRepository extends CrudRepository&Customer, Long& {
* returns the customer for the specified id or
* null if the value is not found
public Customer findCustomerById(String id);}
用如下有缺陷的代码来调用CustomerRepository ：
Customer customer = customerRepository.findCustomerById(&123&);
customer.getName(); // 得到空指针错误
这段代码的正确写法应该是：
Customer customer = customerRepository.findCustomerById(&123&);if(customer != null) {
customer.getName(); // 避免空指针错误
理想状态下，如果我们没有检查某个值能否为空，我们希望编译器及时发现。类让我们可以像这样写接口：
public interface CustomerRepository extends CrudRepository&Customer, Long& {
public Optional&Customer& findCustomerById(String id);}
这样一来，这段代码的有缺陷版本不会被编译，开发者必须显式地检查这个Optional类型对象是否有值，代码如下：
Optional&Customer& optional =
customerRepository.findCustomerById(&123&);if(optional.isPresent()) {
Customer customer = optional.get();
customer.getName();}
所以Optional的关键点在于确保开发者不用查阅Javadoc就能知道某个方法可以返回null，或者可以把一个null值传给某方法。编译器和方法签名有助于开发者明确知道某个值是Optional类型。关于Optional类思想的详细描述请参考。
Spring 4.1有两种方式支持Java Optional。Spring的@Autowired注解有一个属性&required&，使用之后我们可以把如下代码：
public class MyService {
@Autowired(required=false)
OtherService otherS
public doSomething() {
if(otherService != null) {
// use other service
public class MyService {
@Autowired
Optional&OtherService& otherS
public doSomething() {
otherService.ifPresent( s -&
// use s to do something
另一个能用Optional的地方是Spring MVC框架，可以用于表示某个处理方法的参数是可选的。例如：
@RequestMapping(&/accounts/{accountId}&,requestMethod=RequestMethod.POST)
void update(Optional&String& accountId, @RequestBody Account account)
这段代码会告诉Spring其accountId是可选参数。
总之，Java 8的Optional类通过减少空指针错误相关的缺陷简化了代码编写，同时Spring能很好地支持Java 8的Optional类。
参数名发现机制
Java 8支持在编译后的代码中保留方法的参数名。这意味着Spring 4可以从方法中提取参数名，从而使SpringMVC代码更为简洁。例如：
@RequestMapping(&/accounts/{id}&)public Account getAccount(@PathVariable(&id&) String id)
可以改写为：
@RequestMapping(&/accounts/{id}&)public Account getAccount(@PathVariable String id)
可以看到我们把@PathVariable(&id&) 替换成@PathVariable，因为Spring 4能从编译后的Java 8代码中获取参数名&&id。只要在编译时指定了&parameters标记，Java 8编译器就会把参数名写入.class文件中。在Java 8发布之前，Spring也可以从使用-debug选项编译之后的代码中提取出参数名。
在Java 7及之前的版本中，-debug选项不会保留抽象方法的参数名。这会导致Spring Data这类基于Java接口自动生成其资源库实现的工程就会出现问题。比如接口如下：
interface CustomerRepository extends CrudRepository&Customer, Long& {
@Query(&select c from Customer c where c.lastname = :lastname&)
List&Customer& findByLastname(@Param(&lastname&) String lastname);}
我们能看到findByLastname仍然需要@Param(&lastname&)，这是因为findByLastname是个抽象方法，而在Java 7及之前的版本里就算用了-debug选项也不会保留其参数名。而在Java 8中，使用&parameters选项后，Spring Data就能自动找到抽象方法的参数名，我们可以把上例中的接口改写成：
interface CustomerRepository extends CrudRepository&Customer, Long& {
@Query(&select c from Customer c where c.lastname = :lastname&)
List&Customer& findByLastname(String lastname);}
这里我们已经不再需要@Param(&lastname&)，让代码更简洁且易于阅读。所以使用Java 8编译代码时加上&parameters标记是个好方法。
Spring 4支持Java 6、7和8，开发者可以随意使用Java 6、7或8来编写自己的应用代码。如果使用的是Java 8，那么只要有函数式接口的地方就可以使用lambda表达式，使代码更为简洁易读。
Java 8对某些库做了改进，比如新的java.time包和Optional类，Optional类使得用Spring编写的代码更加简单明了。
最后，用&parameters选项编译Java 8代码会在编译时保留方法的参数名，使得开发者得以编写更为紧凑的Spring MVC方法和Spring Data查询方法。
如果你已经准备在项目中使用Java 8，你会发现Spring 4是个很好地利用了Java 8新特性的出色框架。
查看英文原文：
感谢对本文的审校。
给InfoQ中文站投稿或者参与内容翻译工作，请邮件至。也欢迎大家通过新浪微博（，），微信（微信号：）关注我们，并与我们的编辑和其他读者朋友交流。
Author Contacted
语言 & 开发
97 他的粉丝
Spring框架
1 他的粉丝
1680 他的粉丝
告诉我们您的想法
允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p
当有人回复此评论时请E-mail通知我
允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p
当有人回复此评论时请E-mail通知我
允许的HTML标签: a,b,br,blockquote,i,li,pre,u,ul,p
当有人回复此评论时请E-mail通知我
赞助商链接
InfoQ每周精要
订阅InfoQ每周精要，加入拥有25万多名资深开发者的庞大技术社区。
架构 & 设计
文化 & 方法
<及所有内容，版权所有 &#169;
C4Media Inc.
服务器由 提供, 我们最信赖的ISP伙伴。
北京创新网媒广告有限公司
京ICP备号-7
找回密码....
InfoQ账号使用的E-mail
关注你最喜爱的话题和作者
快速浏览网站内你所感兴趣话题的精选内容。
内容自由定制
选择想要阅读的主题和喜爱的作者定制自己的新闻源。
设置通知机制以获取内容更新对您而言是否重要
注意：如果要修改您的邮箱，我们将会发送确认邮件到您原来的邮箱。
使用现有的公司名称
修改公司名称为：
公司性质：
使用现有的公司性质
修改公司性质为:
使用现有的公司规模
修改公司规模为：
使用现在的国家
使用现在的省份
Subscribe to our newsletter?
Subscribe to our industry email notices?
我们发现您在使用ad blocker。
我们理解您使用ad blocker的初衷，但为了保证InfoQ能够继续以免费方式为您服务，我们需要您的支持。InfoQ绝不会在未经您许可的情况下将您的数据提供给第三方。我们仅将其用于向读者发送相关广告内容。请您将InfoQ添加至白名单，感谢您的理解与支持。搭建Spring开发环境并编写第一个Spring小程序
一.前面，我写了一篇Spring框架的基础知识文章，里面没讲到如何配置Spring开发环境，今天就来讲一下，如果大家不知道怎么下载Spring软件包的话
下面，我将用两种方式来讲述如何搭建Spring环境，其中第一种是利用MyEclipse工具里自带的来自动配置Spring，第二种事由我们自己手动配置，有什么区别么，没有什么太大的区别，第一种稍微简单，第二种稍微复杂，但是第二种方式能配置较高版本的Spring，大家看个人爱好了！
二.第一种方式：自动配置方式。
(1).首先，新建一个项目，项目名为one_spring。
(2).选中这个Java项目，点击鼠标右键，选择MyEclipse下的Add Spring Capabilites...这个选项，也可以从菜单栏里选择，选择之后，如下图所示：
为了使我们创建的这个Java项目可以移植，所以我们可以选择最后一个箭头所指向处，选择之后，如下图所示：
点击Browse按钮，选择放置jar包的文件夹，点击之后，如下图所示：
点击Create New Folder后，新建一个文件夹叫lib，专门放置jar包：
点击OK即可，然后我们再点击下图的Next按钮：
点击Next之后，如下图所示：
点击Finish按钮即完成了自动配置Spring的开发环境，点击Finish按钮后，项目文件结构如下图所示：
其中applicationContext为Spring的配置文件。
(3).下面我们就可以编写一个比较简单的Spring的小程序了。
首先，新建一个接口Animal，放在com.inter包下，即Animal.java文件，代码如下：
package com.
public interface Animal {
void eat();//定义抽象的吃方法
void la();//定义抽象的排泄方法
再新建一个Dog类，放在com.bean包下，实现了Animal接口，实现了Animal接口的抽象方法，即Dog.java文件，代码如下：
package com.
import com.inter.A
public class Dog implements Animal{
public void eat() {
// TODO Auto-generated method stub
System.out.println(狗吃狗粮);
public void la() {
// TODO Auto-generated method stub
System.out.println(狗拉狗屎);
再新建一个Cat类，放在com.bean包下，实现了Animal接口，实现了Animal接口的抽象方法，即Cat.java文件，代码如下：
package com.
import com.inter.A
public class Cat implements Animal{
public void eat() {
// TODO Auto-generated method stub
System.out.println(猫吃猫粮);
public void la() {
// TODO Auto-generated method stub
System.out.println(猫拉猫屎);
接下来我们就可以在applicationContext.xml文件里配置Dog和Cat这两个beans对象，具体代码如下：
其中bean标签中的id为这个类的对象取了id，以便后面的标签和代码可用，class是类路径，即包名+类名。
最后，我们新建一个测试类AnimalTest，放在com.test包下，即AnimalTest.java文件，代码如下：
package com.
import org.springframework.context.ApplicationC
import org.springframework.context.support.ClassPathXmlApplicationC
import org.springframework.context.support.FileSystemXmlApplicationC
import com.bean.C
import com.bean.D
public class AnimalTest {
public static void main(String[] args){
ApplicationContext ac=new ClassPathXmlApplicationContext(applicationContext.xml);//查询到配置文件，并赋给ac这个ApplicationContext应用上下文环境对象
Dog d=(Dog) ac.getBean(dog);//获得配置文件中的id为dog这个bean对象
d.eat();//调用eat方法
d.la();//调用排泄方法
Cat c=(Cat)ac.getBean(cat);//获得配置文件中的id为cat这个bean对象
c.eat();//调用eat方法
c.la();//调用排泄方法
项目文件结构如下图所示：
运行后效果如下：
(4).这样就Spring的环境就配置成功了
三.第二种方式：手动配置Spring环境方式。
(1).首先，先下载所需要的Spring软件包，我下载的为Spring4.1.6这个版本的，下载完后得到几个文件夹，配置Spring所需的jar包就在libs下，如下图所示：
(2).接下来我们就在MyEclipse工具里新建一个Java项目，项目名为one_spring1，如下图所示：
然后选中这个项目，鼠标右键选择Build Path & &configure Build Path...这个选项，点开之后如下图所示：
点击右边Add External JARS...按钮，即红色箭头指向处，把我们下载到的软件包下的libs文件夹的jar包添加进去，我们可以把核心的jar包添加进去即可，如下图所示：
其中红色框起来的为Spring的核心jar包，但还缺少一个jar包，这个jar包我下载4.1.6版本的软件包时找不到这个jar包，这个jar包就是commons-logging-1.1.3.jar，这个jar包我是在Struts2的安装包里拿到的，我们也添加进去，如下图所示：
点击OK按钮就可以了，如果是Web项目的话，就把这些核心jar包导入进WEB-INF下的lib文件夹下。
(3).接着我们在项目底下的src目录下新建一个Spring的applicationContext.xml配置文件，其实我们也可以新建成beans.xml，但往往是新建成为第一种，这个文件我们可以从Spring的官网文档里找到，这里我直接附上模板：
我们可以在beans标签里添加bean标签等等！
(4).这样就配置好了Spring的环境了，接下来就是编写测试类了！
首先，编写一个接口Person，放在com.inter包底下，即Person.java文件，代码如下：
package com.
public interface Person {
void eat();//定义抽象的吃方法
void drink();//定义抽象的喝方法
然后定义两个类，分别为NorthMan类和SouthMan类，都放在com.bean包下，实现了Person接口，也实现了接口里的抽象方法
NorthMan.java文件代码如下：
package com.
import com.inter.P
public class NorthMan implements Person{
public void eat() {
// TODO Auto-generated method stub
System.out.println(北方人喜欢吃面食);
public void drink() {
// TODO Auto-generated method stub
System.out.println(北方人喜欢喝酒);
SouthMan.java文件代码如下：
package com.
import com.inter.P
public class SouthMan implements Person{
public void eat() {
// TODO Auto-generated method stub
System.out.println(南方人喜欢吃饭);
public void drink() {
// TODO Auto-generated method stub
System.out.println(南方人喜欢喝茶);
接着在applicationContext.xml配置文件里配置beans，即NorthMan和SouthMan类，applicationContext.xml文件代码如下：
最后编写测试类Test，放在com.test包下，代码如下：
package com.
import org.springframework.context.ApplicationC
import org.springframework.context.support.FileSystemXmlApplicationC
import com.bean.NorthM
import com.bean.SouthM
public class Test {
public static void main(String[] args){
ApplicationContext ac=new FileSystemXmlApplicationContext(src/applicationContext.xml);//利用文件查询applicationContext.xml配置文件
NorthMan n=(NorthMan) ac.getBean(northMan);
n.drink();
SouthMan s=(SouthMan)ac.getBean(southMan);
s.drink();
项目结构文件如下图所示：
运行后效果如下：
(5).这样就Spring的环境就配置成功了。
四.总结：不管是手动配置还是自动配置??Spring的环境，都是大同小异的，看你喜欢用什么方式了，上面我用2种方式配置Spring环境，也写了2个Java项目来测试是否配置成功！其中第一个项目的测试类AnimalTest里的查找配置文件的方式为类路径，第二个项目的测试类的查找配置文件的方式为文件系统。配置文件可以随意放置，但是必须要找到这个配置文件！ 注：大家还是把配置文件放在src目录底下，使用类路径的方式来找到！这样比较简单，也不会出现错误！博客分类：
前几天一时兴起,看到一个基于RESTful web Service的很不错的框架 jersey .并且做了一个小小的案例.
说起jersey,应该首先简要的阐述一下REST,REST概念是由加州大学的Roy Fielding 在2000年提出,REST不是一种技术,它是一种开发方式和风格,REST 定义了一组体系架构原则，您可以根据这些原则设计以系统资源为中心的 Web 服务，包括使用不同语言编写的客户端如何通过 HTTP 处理和传输资源状态，也已经普遍地取代了基于 SOAP 和 WSDL 的接口设计。而Jersey是一个REST 很好的轻量级实现框架.
刚听说jersey的时候,我并不是很倾向,因为在此之前基于RESTful的实现框架有很多,比如XFire,Restlet,Resteasy等等,但我还是使用了之后,觉得它与Spring完美集成,让我们在开发中提高了很多小于,也相对的减少非法侵入.
下面我们来搭建一个jersey的web service Project：
我的IDE环境是myeclipse,jre 在jdk1.6上
web 服务器是tomcat 6
一、第一步新建一个web project 。
二、然后将相关的spring
jar包导入项目中, spring-core,aop,beans,jdbc,context,asm,orm,web等去官网下载
中所有的jar包
三、下载jersey 相关的jar包
四、 导入aopalliance.jar 不然会报错 找不到相关文件，log4j jar 和log4j.properties
创建自己的应用程序
我现在直接写一个helloworld对象 将helloworl 对象通过webservice 访问来返回相关数据格式的数据
package com.jerrys.jerseyrest.
import java.io.S
import java.util.HashM
import java.util.M
import javax.xml.bind.annotation.XmlRootE
@XmlRootElement
public class Helloworld implements Serializable {
private Map&String, Object& helloMap = new HashMap&String, Object&();
public Helloworld() {
helloMap.put("xiaoming", "我是小明:");
helloMap.put("xiaoqiang", "我是小强:");
public Object getHelloByName(String name) {
return helloMap.get(name);
public String getContent() {
public void setContent(String content) {
this.content =
public Map&String, Object& getHelloMap() {
return helloM
public void setHelloMap(Map&String, Object& helloMap) {
this.helloMap = helloM
@XmlRootElement 是jax-rs中 提供将对象的属性绑定返回时将已json或者xml等数据返回.
package com.jerrys.jerseyrest.
import javax.ws.rs.GET;
import javax.ws.rs.P
import javax.ws.rs.P
import javax.ws.rs.core.MediaT
import org.apache.log4j.L
import com.jerrys.jerseyrest.entity.H
@Path("/helloService")
public class HelloRestService {
public static Logger log = Logger.getLogger(HelloRestService.class);
* 获取helloworld
@Path("/hello")
@Produces( { MediaType.APPLICATION_JSON })
public Helloworld getHelloworld() {
Helloworld hi =
hi = new Helloworld();
hi.setContent((String) hi.getHelloByName("xiaoqiang"));
} catch (Exception e) {
log.error(e.getMessage(), e);
e.printStackTrace();
@Path("/helloWervice")
是你访问该HelloRestService 资源的uri 标识对应的url访问路径是: http://localhost:8080/projectName/helloWervice
@Path(/hello)
HelloRestService
中getHelloworld()方法上是访问该方法资源的uri标识,对应的url路径是
http://localhost:8080/projectName/helloWervice/hello
我们可以定义该方法是用来获取资源数据的所以我们可以定义成@GET,如果是@PUT那就是更新,@DELETE是删除资源,@POST创建。也可以叠加
@Produces({ MediaType.APPLICATION_JSON }定义了我们返回的数据格式.这边我们直接用的变量,我们也可以直接写"application/xml","application/json","text/html"
当然我们也可以定义参数@PathParam("name") 定义传值的参数
接下来我们来配置Web.xml
&?xml version="1.0" encoding="UTF-8"?&
&web-app version="2.5" xmlns="/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="/xml/ns/javaee
/xml/ns/javaee/web-app_2_5.xsd"&
&display-name&jax-rs&/display-name&
&!-- Helps locate the applicationContext.xml file --&
&context-param&
&param-name&contextConfigLocation&/param-name&
&param-value&classpath:applicationContext.xml&/param-value&
&/context-param&
&listener&
&listener-class&org.springframework.web.context.ContextLoaderListener&/listener-class&
&/listener&
&listener&
&listener-class&org.springframework.web.context.request.RequestContextListener&/listener-class&
&/listener&
&filter-name&encodingFilter&/filter-name&
&filter-class&org.springframework.web.filter.CharacterEncodingFilter&/filter-class&
&init-param&
&param-name&encoding&/param-name&
&param-value&UTF-8&/param-value&
&/init-param&
&init-param&
&param-name&forceEncoding&/param-name&
&param-value&true&/param-value&
&/init-param&
&filter-mapping&
&filter-name&encodingFilter&/filter-name&
&url-pattern&/*&/url-pattern&
&/filter-mapping&
&!-- Configuration for Jersey Web Services starts here --&
&servlet-name&jersey&/servlet-name&
&servlet-class&com.sun.jersey.spi.container.servlet.ServletContainer&/servlet-class&
&init-param&
&param-name&com.sun.jersey.config.property.packages&/param-name&
&!-- The package in which the Resource classes located--&
&param-value&com.jerrys.jerseyrest.webservice&/param-value&
&/init-param&
&load-on-startup&1&/load-on-startup&
&/servlet&
&servlet-mapping&
&servlet-name&jersey&/servlet-name&
Enables us to access the WS by pointing your browser to this URL :
http://localhost:8080/any_name/{service-path}
&url-pattern&/*&/url-pattern&
&/servlet-mapping&
&!-- Configuration for Jersey Web Services ends here --&
&session-config&
&session-timeout&10&/session-timeout&
&/session-config&
&welcome-file-list&
&welcome-file&index.jsp&/welcome-file&
&/welcome-file-list&
&/web-app&
加载jersey
和Srping 的servlet
然后在创建 applicationContext.xml 的spring配置文件
&?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"
default-lazy-init="true" &
&!-- 使用Annotation(注解)自动注册Bean(自注入) ,并检查@Required,@Autowired的属性已被注入 --&
&context:component-scan base-package="com.jerrys.jerseyrest"&&/context:component-scan&
&!-- JOTM本地实例 --&
&bean id="jotm" class="org.springframework.transaction.jta.JotmFactoryBean" /&
&bean id="txManager"
class="org.springframework.transaction.jta.JtaTransactionManager"&
&property name="userTransaction" ref="jotm"&&/property&
&bean id="jta1Datasource" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource"
destroy-method="shutdown"&
&property name="dataSrouce"&
&bean class="org.enhydra.jdbc.standard.StandardXADataSource"
destroy-method="shutdown"&
&property name="transactionManager" ref="jotm" /&
&property name="driverName" value="com.mysql.jdbc.Driver" /&
&property name="url" value="jdbc:mysql://192.168.1.20:3306/jtatest1" /&
&/property&
&property name="user" value="root"&&/property&
&property name="password" value="zgjf168"&&/property&
&bean id="jta2Datasource" class="org.enhydra.jdbc.pool.StandardXAPoolDataSource"
destroy-method="shutdown"&
&property name="dataSrouce"&
&bean class="org.enhydra.jdbc.standard.StandardXADataSource"
destroy-method="shutdown"&
&property name="transactionManager" ref="jotm" /&
&property name="driverName" value="com.mysql.jdbc.Driver" /&
&property name="url" value="jdbc:mysql://192.168.1.20:3306/jtatest2" /&
&/property&
&property name="user" value="root"&&/property&
&property name="password" value="zgjf168"&&/property&
&bean id="jta1Template" class="org.springframework.jdbc.core.JdbcTemplate"&
&property name="datasource" ref="jta1Datasource" /&
&bean id="jta2Template" class="org.springframework.jdbc.core.JdbcTemplate"&
&property name="datasource" ref="jta2Datasource" /&
&!-- 注解事务驱动 --&
&tx:annotation-driven transaction-manager="txManager"
proxy-target-class="true" /&
我在jersey与spring整合同时,我也提到了使用JTA分布式事务 的配置,但这边只是一个案例，仅提供参考,所以没有集成整合Hibernate
所以请包涵.
对于JTA分布式事务
的详细概念
我在这就不一一阐述了.请参见
功能还待完善,如有不正确的观点,请予以点评.
浏览 12397
请求进来时，创建的对象都不是由Spring弄出来的。。首先你可以先去了解一下JAX-WS 和JAX-RS& JSR311 Standard创建的对象Spring MVC 也是遵循的 JAX-RS 规范& 我Jersey 也是。你的对象上加入 @XmlRootElement 这个注解自动会帮你传进来的json数据 进行封装成对象The @XmlRootElement annotation can be used with the following program elements:
徜徉の小溪
浏览: 255461 次
来自: 上海
yuanliangding 写道请求进来时，创建的对象都不是由 ...
请求进来时，创建的对象都不是由Spring弄出来的。。
我已经按照你的xml这个顺序配置了，结果还是中文乱码。是还有什 ...
作者的实体图画的很好很有条理，但是个人觉得用户组对应的是资源， ...
求教一个问题，如果我想过滤静态资源，该怎么配置？
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'}