当前访客身份：游客 [
这个人很懒，啥也没写
： MOOC Providers ( Coursea, ...
：http://ask.39.net/question/.html...
：/question/.ht...
：/shenzhen/bang/895674 深...
：/software/imgscalr...
：/software/imgscalr...
：-------------------------------- Eclipse报错：...
：/tagcloud/H5FiN5nakqwFp2...
：/wenda-120R.html...
今日访问：11
昨日访问：16
本周访问：147
本月访问：605
所有访问：4041
怎样使用Groovy给XML增加特性
发表于9个月前( 21:06)&&
阅读（156）&|&评论（）
0人收藏此文章,
怎样使用Groovy给XML增加特性?
在Groovy中，我需要增加一个特性（attribute）到XML的根元素。我想使用 XmlSlurper。该怎样做？增加元素是很简单。
在Groovy Console 运行以下代码，结果良好。
import&groovy.xml.StreamingMarkupBuilder
//&the&original&XML
def&input&=&"&foo&&bar&&/bar&&/foo&"
//&add&attributeName="attributeValue"&to&the&root
def&root&=&new&XmlSlurper().parseText(input)
root.@attributeName&=&'attributeValue'
//&get&the&modified&XML&and&check&that&it&worked
def&outputBuilder&=&new&StreamingMarkupBuilder()
String&updatedXml&=&outputBuilder.bind{&mkp.yield&root&}
assert&"&foo&attributeName='attributeValue'&&bar&&/bar&&/foo&"&==&updatedXml
增加一个特性与读一个特性是一样的：
import&groovy.xml.StreamingMarkupBuilder
def&input&=&'''
&&&&&more&
&&&&&/more&
&/thing&'''
def&root&=&new&XmlSlurper().parseText(input)
root.@stuff&=&'new'
def&outputBuilder&=&new&StreamingMarkupBuilder()
String&result&=&outputBuilder.bind{&mkp.yield&root&}
println&result
&thing&stuff='new'&&more&&/more&&/thing&
更多开发者职位上
1)">1)">1" ng-class="{current:{{currentPage==page}}}" ng-repeat="page in pages"><li class='page' ng-if="(endIndex<li class='page next' ng-if="(currentPage
相关文章阅读什么是 Groovy_百度知道
什么是 Groovy
提问者采纳
可以使用这些强大的构造做许多漂亮的事.它需要JDK 1。在学习本教程的过程中。
一体两面 用Groovy 编写的任何内容都可以编译成标准的 Java 类文件并在 Java 代码中重用;● 是一个基于 Java虚拟机的敏捷 动态语言, dom4j，Groovy 可能是您最近听说过的类型最松散的动态语言之一，您会发现它使日常的编程活动变得快了许多，使得它们更容易使用，然后程序化地初始化 &lt，Ruby 与 Groovy 不同，您会了解更多的 Groovy 语法快捷方式，这样可以在任何使用Java的地方 使用Groovy。
动态的 Groovy 从技术上讲。
Groovy 在普通的常用 Java 对象上增加了一些独特的方法和快捷方式。
Groovy是用Java实现的开源脚本语言并且和它联系紧密。
● 无缝集成 所有已经存在的 Java对象和类库，您会惊讶地发现，Java 语言是一种固定类型语言，然后 再向实例中添加项。
Groovy 的一个好处是，成为正式的 Java 语法，但现在已经可以在 Groovy 中使用了，GUI。）
Groovy 快捷方式 开始使用 Groovy 时。而且，数据库或控制台程序时 通过 减少框架性代码 大大提高了开发者的效率。
● Groovy拥有处理原生类型.4,Groovy 代码还能在运行时轻松地改变自己。所以，闭包都是一个令人兴奋的新技巧。
● 直接编译成Java字节码。
●为Java开发者提供了 现代最流行的编程语言特性;(分号可有可无),可以使用def myStr = &quot。可以将闭包 想像为一个代码块, Betwixt和MHello& 实例，例如本地集合，它的语法与 Java 语言的语法很相似，Ruby和Smalltalk等语言中学到的 诸多特征。完成本教程之后. Groovy向Java添加了许多Ruby和Python脚本语言的特性。
关于闭包 对于任何 Java 开发人员来说。在 Groovy 中，用标准 Java 代码编写的内容也可以在 Groovy 中重用.
Groovy是由James Strachan和Bob McWhirter创造的，在 Groovy 会使操作 XML 或普通的 java。这些神奇的构造将会包含在未来的 Java 发行版（很可能是 Java 7）中.ArrayList&lt。这一编程领域称为元编程。不过现在只需知道以下这些要点，列表和映射都内置在语法中 — 无需导入任何内容;.
目前最新稳定版为Groovy1.io, 闭包（closures），同时无需定义正规的class 对象，因为它的语法与 Java 语法差异很大、内置的正则表达式和闭包，可以现在定义。
Groovy 的新增特性 虽然Groovy 允许省略 Java 语法中的一些元素。
除非另行指定，以后再执行,简单对象导航（ easy object navigation）和更加简洁的Lists和Maps语法;，可以轻易地使用 Groovy 为 Java 代码编写单元测试;code&gt、表达能力更强的变体，能够在运行时轻松地为对象指定新方法和属性，不过最著名的是简化迭代，其中包括Jelly，让你的代码变得易于阅读和维护。（在这点上; 来声明 String 变量。
● 支持单元测试和模拟（对象）;code&gt。
● 支持DSL（Domain Specific Languages领域定义语言）和其它简洁的语法，面向对象以及一个Ant DSL;java. James还参与了许多其他开源项目的开发. Bob是Jaxen和Drools (一个开源的面向对象的JAVA规则引擎) 的创始人。
Groovy 语法还允许省略变量类型;code&gt，而且学习成本很低（几乎为零），所以您不必输入String myStr = &quot。从这个角度讲。现在惟一要补充的是;/ArrayList&lt，Groovy 与 Java 语言的区别很大；它们可以通过特殊的 Groovy 语法来创建，类型是可选的。使用 Groovy 之后，可以 简化测试，那么也可以在 Java 程序中使用这个小工具. Groovy的特性包括动态类型（dynamic typing）;code&gt。类似地，如果想要创建一个项列表，Groovy 的所有内容都为 public。
● 在开发Web。这实际上意味着, JHello&quot，但也增加了一些新特性。正则表达式也不需要额外的导入或对象，您将了解到关于 Groovy 的动态性质的更多内容，使得创建Shell Scripts变的非常简单，但是可以将它想像成 Java 语言的一种更加简单，Groovy 能够很好地支持这种编程方式。
● 构建在强大的Java语言之上 并 添加了从Python，首先要导入&lt。虽然 Groovy 的语法源于 Smalltalk 和 Ruby 这类语言的理念，如果用 Groovy 编写一个方便的小工具，就有可能再也不需要编写Iterator 实例了。在 Groovy 中。在标准的 Java 代码中：
Groovy 的松散的 Java 语法允许省略分号和修改符;&#47.File 实例变得非常轻松。
除此之外.8。
Groovy 允许定义简单脚本.util
其他类似问题
为您推荐：
groovy的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁人气：2613119
访问用户量：3429
笔记经验：3830
总积分：261644
级别：VIP5
搜索本笔记
ta的交流分类
ta的全部笔记
浏览(7871)|(0)
&&交流分类：|笔记分类:
Spring4支持使用Groovy DSL来进行Bean定义配置，其类似于XML，不过因为是Groovy DSL，可以实现任何复杂的语法配置，但是对于配置，我们需要那么复杂吗？本着学习的态度试用了下其Groovy DSL定义Bean，其主要缺点：
1、DSL语法规则不足，需要其后续维护；
2、编辑器的代码补全需要跟进，否则没有代码补全，写这个很痛苦；
3、出错提示不友好，排错难；
4、当前对于一些配置还是需要XML的支持，所以还不是100%的纯Groovy DSL；
5、目前对整个Spring生态支持还是不够的，比如Web，需要观望。
其优点就是其本质是Groovy脚本，所以可以做非常复杂的配置，如果以上问题能够解决，其也是一个不错的选择。在Groovy中的话使用这种配置感觉不会有什么问题，但是在纯Java开发环境下也是有它，给我的感觉是这个功能其目的是去推广它的groovy。比较怀疑它的动机。
接下来我们来看看Spring配置的发展：
Spring 2时代是XML风格配置 &可以参考《》的前几章
Spring 3时代引入注解风格配置 &可以参考《》的&
Spring 4时代引入Groovy DSL风格来配置 后续讲解
对于我来说，没有哪个好/坏，只有适用不适用；开发方便不方便。接下来我们来看一下各种类型的配置吧：
XML风格配置
&context:component-scan base-package=&com.sishuok.spring4&/&
&bean class=&org.springframework.validation.beanvalidation.MethodValidationPostProcessor&&
&property name=&validator& ref=&validator&/&
&mvc:annotation-driven validator=&validator&/&
&bean id=&validator& class=&org.springframework.validation.beanvalidation.LocalValidatorFactoryBean&&
&property name=&providerClass& value=&org.hibernate.validator.HibernateValidator&/&
&property name=&validationMessageSource& ref=&messageSource&/&
注解风格配置&
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = &com.sishuok.spring4&)
public class MvcConfiguration extends WebMvcConfigurationSupport {
protected Validator getValidator() {
LocalValidatorFactoryBean localValidatorFactoryBean =
new LocalValidatorFactoryBean();
localValidatorFactoryBean.setProviderClass(HibernateValidator.class);
localValidatorFactoryBean.setValidationMessageSource(messageSource());
return localValidatorFactoryB
Groovy DSL风格配置
import org.hibernate.validator.HibernateValidator
import org.springframework.context.support.ReloadableResourceBundleMessageSource
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean
xmlns context: &http://www.springframework.org/schema/context&
xmlns mvc: &http://www.springframework.org/schema/mvc&
context.'component-scan'('base-package': &com,sishuok.spring4&)
mvc.'annotation-driven'('validator': &validator&)
validator(LocalValidatorFactoryBean) {
providerClass = HibernateValidator.class
validationMessageSource = ref(&messageSource&)
因为Spring4 webmvc没有提供用于Web环境的Groovy DSL实现的WebApplicationContext，所以为了在web环境使用，单独写了一个WebGenricGroovyApplicationContext，可以到源码中查找。
可以看到，它们之前差别不是特别大；以上只提取了部分配置，完整的配置可以参考我的github：
对于注解风格的配置，如果在Servlet3容器中使用的话，可以借助WebApplicationInitializer实现无配置：
public class AppInitializer implements WebApplicationInitializer {
public void onStartup(javax.servlet.ServletContext sc) throws ServletException {
AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
rootContext.register(AppConfig.class);
sc.addListener(new ContextLoaderListener(rootContext));
//2、springmvc上下文
AnnotationConfigWebApplicationContext springMvcContext = new AnnotationConfigWebApplicationContext();
springMvcContext.register(MvcConfiguration.class);
//3、DispatcherServlet
DispatcherServlet dispatcherServlet = new DispatcherServlet(springMvcContext);
ServletRegistration.Dynamic dynamic = sc.addServlet(&dispatcherServlet&, dispatcherServlet);
dynamic.setLoadOnStartup(1);
dynamic.addMapping(&/&);
//4、CharacterEncodingFilter
FilterRegistration filterRegistration =
sc.addFilter(&characterEncodingFilter&, CharacterEncodingFilter.class);
filterRegistration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), false, &/*&);
到底好还是不好，需要根据自己项目大小等一些因素来衡量。对于Servlet3可以参考我github的示例：&
对于Groovy风格配置，如果语法足够丰富、Spring内部支持完善，且编辑器支持也非常好的话，也是不错的选择。
二、Groovy Bean定义
接下来我们来看下groovy DSL的具体使用吧：
1、安装环境
&dependency&
&groupId&org.codehaus.groovy&/groupId&
&artifactId&groovy-all&/artifactId&
&version&${groovy.version}&/version&
&/dependency&
我使用的groovy版本是2.2.1
2、相关组件类
此处使用Spring Framework官网的hello world，可以前往&主页查看&
3、Groovy Bean定义配置文件
import com.sishuok.spring4.xml.MessageServiceImpl
import com.sishuok.spring4.xml.MessagePrinter
messageService(MessageServiceImpl) {//名字(类型)
message = &hello&
//注入的属性
messagePrinter(MessagePrinter, messageService) //名字（类型，构造器参数列表）
从此处可以看到 如果仅仅是简单的Bean定义，确实比XML简洁。
如果不测试环境可以这样测试：
public class XmlGroovyBeanDefinitionTest1 {
public void test() {
ApplicationContext ctx = new GenericGroovyApplicationContext(&classpath:spring-config-xml.groovy&);
MessagePrinter messagePrinter = (MessagePrinter) ctx.getBean(&messagePrinter&);
messagePrinter.printMessage();
使用GenericGroovyApplicationContext加载groovy配置文件。&
如果想集成到Spring Test中，可以这样：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = &classpath:spring-config-xml.groovy&, loader = GenericGroovyContextLoader.class)
public class XmlGroovyBeanDefinitionTest2 {
@Autowired
private MessagePrinter messageP
public void test() {
messagePrinter.printMessage();
此处需要定义我们自己的bean loader，即从groovy配置文件加载：
public class GenericGroovyContextLoader extends AbstractGenericContextLoader {
protected String getResourceSuffix() {
throw new UnsupportedOperationException(
&GenericGroovyContextLoader does not support the getResourceSuffix() method&);
protected BeanDefinitionReader createBeanDefinitionReader(GenericApplicationContext context) {
return new GroovyBeanDefinitionReader(context);
使用GroovyBeanDefinitionReader来加载groovy配置文件。&&
到此基本的使用就结束了，还算是比较简洁，但是我们已经注意到了，在纯Java环境做测试还是比较麻烦的。 比如没有给我们写好相关的测试支撑类。另外大家可以前往Spring的github看看在groovy中的单元测试：
再看一下我们使用注解方式呢：
@Component
public class MessageServiceImpl implements MessageService {
@Autowired
@Qualifier(&message&)
@Component
public class MessagePrinter {
private MessageService messageS
@Autowired
public MessagePrinter(MessageService messageService) {
this.messageService = messageS
此处省略无关代码，需要的话直接去github查看 。&
Groovy配置文件：
xmlns context: &http://www.springframework.org/schema/context&
//导入命名空间
context.'component-scan'('base-package': &com.sishuok.spring4&) {
'exclude-filter'('type': &aspectj&, 'expression': &com.sishuok.spring4.xml.*&)
message(String, &hello&) {}
} 在该配置文件中支持导入xml命名空间， 其中context.'component-scan'部分等价于XML中的：
&context:component-scan base-package=&com.sishuok.spring4&&
&context:exclude-filter type=&aspectj& expression=&com.sishuok.spring4.xml.*&/&
&/context:component-scan&
&从这里可以看出，其还没能完全从XML风格配置中走出来，不是纯Groovy DSL。
测试方式和之前的一样就不重复了，可以查看。
三、Groovy Bean定义 DSL语法
到目前为止，基本的helloworld就搞定了；接下来看看Groovy DSL都支持哪些配置吧：
validator(LocalValidatorFactoryBean) { //名字（类型）
providerClass = HibernateValidator.class
validationMessageSource = ref(&messageSource&) //属性 = 引用，当然也支持如 validationMessageSource=messageSource 但是这种方式缺点是messageSource必须在validator之前声明
静态工厂方法
def bean = factory(StaticFactory) {
bean.factoryMethod = &getInstance& 或者
bean(StaticFactory) { bean -&
bean.factoryMethod = &getInstance&
实例工厂方法
beanFactory(Factory)
bean(beanFactory : &newInstance&, &args&) {
beanFactory(Factory)
bean(&bean&){bean -&
bean.factoryBean=&beanFactory&
bean.factoryMethod=&newInstance&
beanName(BeanClass) { //名字（类型）
str = &123& // 常量直接注入
bean = ref(&bean&) //属性 = 引用 ref(&bean&, true) 这样的话是引用父容器的
beans = [bean1, bean2] //数组/集合
props = [key1:&value1&, key2:&value2&] // Properties / Map
构造器注入&
bean(Bean, &args1&, &args2&)&
静态工厂注入/实例工厂注入，请参考创建bean部分
匿名内部Bean
outer(OuterBean) {
{ InnerBean bean -&
//匿名内部Bean
outer(OuterBean) {
//匿名内部Bean 通过实例工厂方法创建
bean.factoryBean = &innerBean&
bean.factoryMethod = &create&
单例/非单例/作用域
singletonBean(Bean1) { bean -&
bean.singleton = true
nonSingletonBean(Bean1) { bean -&
bean.singleton = false
prototypeBean(Bean1) { bean -&
bean.scope = &prototype&
& 其中bean可以理解为xml中的&bean& 标签，即bean定义。
parent(Bean1){ bean -&
bean.'abstract' = true //抽象的
prop = 123
child { bean -&
bean.parent = parent //指定父bean
xmlns aop:&http://www.springframework.org/schema/aop&
myAspect(MyAspect)
config(&proxy-target-class&:true) {
aspect( id:&test&,ref:&myAspect& ) {
before method:&before&, pointcut: &execution(void com.sishuok.spring4..*.*(..))&
} 以上是AOP的，可以自己推到其他相关的配置；&
xmlns context: &http://www.springframework.org/schema/context&
context.'component-scan'('base-package': &com.sishuok.spring4&) {
'exclude-filter'('type': &aspectj&, 'expression': &com.sishuok.spring4.xml.*&)
} 以上是component-scan，之前介绍过了。
xmlns aop:&http://www.springframework.org/schema/aop&
scopedList(ArrayList) { bean -&
bean.scope = &haha&
aop.'scoped-proxy'()
&bean id=&scopedList& class=&java.util.ArrayList& scope=&haha&&
&aop:scoped-proxy/&
xmlns util:&http://www.springframework.org/schema/util&
util.list(id : 'list') {
等价于XML：
&util:list id=&list&&
&value&1&/value&
&value&2&/value&
&/util:list&
xmlns util:&http://www.springframework.org/schema/util&
util.map(id : 'map') {
entry(key : 1, value :1)
entry('key-ref' : &messageService&, 'value-ref' : &messageService&)
&util:map id=&map&&
&entry key=&1& value=&1&/&
&entry key-ref=&messageService& value-ref=&messageService&/&
&/util:map&
引入其他配置文件
importBeans &classpath:org/springframework/context/groovy/test.xml& 当然也能引入XML的。&
对于DSL新的更新大家可以关注：，本文也是根据其编写的。
再来看看groovy bean定义的另一个好处：
我们可以直接在groovy bean定义文件中声明类，然后使用
@Controller
def class GroovyController {
@RequestMapping(&/groovy&)
@ResponseBody
public String hello() {
return &hello&;
groovyController(GroovyController)
&另一种Spring很早就支持的方式是引入外部groovy文件，如：
xmlns lang: &http://www.springframework.org/schema/lang&
lang.'groovy'(id: 'groovyController2', 'script-source': 'classpath:com/sishuok/spring4/controller/GroovyController2.groovy')
使用其lang命名空间引入外部脚本文件。
到此，Groovy Bean定义DSL就介绍完了，其没有什么特别之处，只是换了种写法而已，我认为目前试试即可，还不能用到真实环境。
示例代码：
相关笔记推荐
精品视频课程推荐
本视频课程是北京Java私塾原创精品书籍《研磨设计模式》一书的配套学习视频，由《研磨设计模式》的第一作者CC录制
课程目标：全面、系统的掌握GoF设计模式的知识，达到可以在实际项目开发中运用的能力
技术要点：如何实现可配置、如何实现缓存以及缓存的管理、如何实现用缓存来控制多实例的创建、如何实现参数化工厂、 如何实现可扩展工厂、如何实现原型管理器、如何实现Java的静态代理和动态代理、如何实现多线程处理队列请求、 如何实现命令的参数化配置、可撤销的操作、宏命令、队列请求和日志请求、如何实现翻页迭代、如何检测环状结构、 如何实现通用的增删改查、如何模拟工作流来处理流程、如何实现简单又通用的XML读取、如何实现模拟AOP的功能......
内容概述：Shiro是目前最热门、最易用、功能超强大的Java权限管理框架，强烈推荐，每个项目都必备的权限管理技术！通过本课程，你将从零开始直到彻底掌握Shiro的相关开发知识，达到可以进行实际项目开发的能力。包括：权限管理基础、Shiro入门、配置、身份认证、授权、Realms、Session管理、和Spring的集成、Web、Cache等众多开发细节技术
技术要点：源码级分析Shiro的授权过程、自定义开发Realm、多个Realms的开发配置、自定义开发AuthenticationStrategy、自定义开发自定义SessionDAO、和Struts2+Spring3的集成（包括修正struts2的bug）、Shiro和SpringMVC+Spring3的集成、包装使用其他的Cache框架、缓存数据同步更新的解决方案等等实际开发中常用的内容
系统、完整的学习Spring Web MVC开发的知识。包括：Spring Web MVC入门；理解DispatcherServlet；注解式控制器开发详解；数据类型转换；数据格式化；数据验证； 拦截器；对Ajax的支持；文件上传下载；表单标签等内容；最后以一个综合的CRUD带翻页的应用示例来综合所学的知识
系统、完整的学习Spring Data JPA开发的知识。包括：Spring Data JPA入门；JpaRepository基本功能 ；JpaRepository的查询；客户化扩展JpaRepository；Specifications查询。
数据校验、Javascript模拟多线程、下拉列表联动、操作XML、AJAX结合JSON的操作、Json-lib的使用
浏览(7871)|(0)
&&交流分类：|笔记分类:
版权所有 Copyright(C) 私塾在线学习网