欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Grails Grails和 Spring

程序员文章站 2022-04-30 19:00:06
...

 

Grails和 Spring

这一节适合于高级用户， Spring 框架，和想通过 插件开发来配置Grails的开发人员。

14.1 Grails内部实现

实际上Grails是变相的 Spring MVC 应用. Spring MVC是Spring框架内置的 MVC web开发框架.虽然从易用性来说Spring MVC比不上Struts这样的框架,但它的设计和架构都非常优秀，正适合在其基础之上构建另一个像Grails这样的框架。

Grails在以下方面利用了Spring MVC:

  • 基本控制器逻辑 - Grails继承Spring的 DispatcherServlet并使用它作为代理将请求转发给 Grails的控制器
  • 数据绑定和校验 - Grails的校验 和 数据绑定正是建立在Spring的数据绑定和校验之上
  • 运行时配置 - Grails的整个"约定优先配置"机制全部用Spring来实现ApplicationContext
  • 事务处理 - Grails GORM使用Spring的事务处理

也就是说Grails内嵌Spring并在框架的各个环节上使用Spring.

 

Grails ApplicationContext

Spring开发人员经常热衷于想知道Grails中的ApplicationContext实例是怎么创建的.基本过程如下：

  • Grails通过web-app/WEB-INF/applicationContext.xml创建一个父ApplicationContext对象。 这个ApplicationContext对象设置 GrailsApplication 对象 and GrailsPluginManager对象.
  • 使用这个 ApplicationContext 作为父对象 Grails通过“约定优先”分析 GrailsApplication 对象构建一个子ApplicationContext对象，此对象作为web应用的 ApplicationContext

 

配置Spring Beans

大部分Grails的配置都是在运行时进行. 每个 插件 都可以配置在上面创建的ApplicationContext对象中注册过的Spring bean. For a reference as to which beans are configured refer to the reference guide which describes each of the Grails plug-ins and which beans they configure.

14.2 配置其他Bean

使用XML

Beans可用过grails-app/conf/spring/resources.xml 来配置. 这个文件是一个标准的Spring配置文件，在Spring Spring参考文档中对如何配置Spring Beans有详细描述。下面是一个简单的例子:

 

<bean id="myBean" class="my.company.MyBeanImpl"></bean>

配置完毕后, myBean就可以在Grails 控制器，标签库，服务等很多地方引用：

 

class ExampleController {
     def myBean
}

 

引用现有的Spring bean

在resources.xml中声明的bean也可以通过约定来引用Grails类 . 比如， 如果你想在你的bean中引用 BookService这样一个service，你可以用如下的代码：

 

<bean id="myBean" class="my.company.MyBeanImpl">
        <property name="bookService" ref="bookService" />        
</bean>

这个bean本身需要一个 public setter方法，在Groovy中这样定义:

 

package my.company
class MyBeanImpl {
        BookService bookService
}

或在Java中:

 

package my.company;
class MyBeanImpl {
        private BookService bookService;
        public void setBookService(BookService theBookService) {
                this.bookService = theBookService;
        }
}

既然大部分Grails配置都是在运行时通过约定机制来完成，大部分bean并不需要声明, 但仍然可以在Spring应用中进行引用. 如你需要引用一个Grails DataSource 你可以这样:

 

<bean id="myBean" class="my.company.MyBeanImpl">
        <property name="bookService" ref="bookService" />        
        <property name="dataSource" ref="dataSource" />
</bean>

或者你需要引用Hibernate SessionFactory:

 

<bean id="myBean" class="my.company.MyBeanImpl">
        <property name="bookService" ref="bookService" />        
        <property name="sessionFactory" ref="sessionFactory" />
</bean>

所有提供的bean既说明可参考插件开发文档.

 

使用Spring DSL

如果你想使用Grails提供的 Spring DSL ，你必须创建grails-app/conf/spring/resources.groovy 文件，定义一个 beans属性块:

 

beans = {
        // 定义的beans
}

同样在的配置可以应用于XML例子:

 

beans = {
        myBean(my.company.MyBeanImpl) {
                bookService = ref("bookService")
        }  
}

这样做最大的好处是你能够在bean的定义中混合各种逻辑，如基于 environment:

 

import grails.util.*
beans = {
        switch(GrailsUtil.environment) {
                case "production":
                        myBean(my.company.MyBeanImpl) {
                                bookService = ref("bookService")
                        }
           break
                case "development":
                        myBean(my.company.mock.MockImpl) {
                                bookService = ref("bookService")
                        }  
                break
        }  
}

 

14.3 运行时Spring与Beans DSL

Grails提供BeanBuilder的目的是提供一种简化的方法来关联使用Spring的各中依赖关系.

这是因为Spring的常规配置方法（通过XML）在本质上是静态的，除了通过程序方式来动态产生XML配置文件外，很难在运行时修改和添加程序配置。而且这种方法非常繁琐，也容易出错. Grails的BeanBuilder 改变了这一点，它可以让你在运行时通过系统属性和环境属性来动态改变程序逻辑.

这使得程序代码动态适配它的环境，避免不必要的重复代码（如在Spring中为测试环境，开发环境和生产环境做不同的配置)

 

BeanBuilder 类

Grails提供了 grails.spring.BeanBuilder 类使用动态Groovy来创建bean的声明. 基本点如下:

 

import org.apache.commons.dbcp.BasicDataSource
import org.codehaus.groovy.grails.orm.hibernate.ConfigurableLocalSessionFactoryBean;
import org.springframework.context.ApplicationContext;
def bb = new grails.spring.BeanBuilder()

bb.beans {
    dataSource(BasicDataSource) {
        driverClassName = "org.hsqldb.jdbcDriver"
        url = "jdbc:hsqldb:mem:grailsDB"
        username = "sa"
        password = ""
    }
    sessionFactory(ConfigurableLocalSessionFactoryBean) {
        dataSource = dataSource
        hibernateProperties = [ "hibernate.hbm2ddl.auto":"create-drop",
                                "hibernate.show_sql":true  ]
    }
}

ApplicationContext appContext = bb.createApplicationContext()

 

在 插件 和 grails-app/conf/spring/resources.groovy 文件中你不需要创建一个BeanBuilder实例， 它在 doWithSpring 和 beans块中都隐式存在.

上面这个例子说明了如果使用 BeanBuilder类来配置某个特定的Hibernate数据源。

实际上，每个方法调用( dataSource 和 sessionFactory 调用) 都映射到Spring中的bean的名字. 方法的第一个参数是bean的class名字, 最后一个参数是一个块（block）. 在块内部可以用标准的Groovy语法设置bean的属性。

通过bean的名字自动查找bean的引用. 通过上面的sessionFactory bean解析dataSource可以看点这一点。

也可以通过builder设置一些与bean管理相关的特殊的bean属性，如：

 

sessionFactory(ConfigurableLocalSessionFactoryBean) { bean ->
    bean.autowire = 'byName'       // Autowiring behaviour. The other option is 'byType'. [autowire]
    bean.initMethod = 'init'       // Sets the initialisation method to 'init'. [init-method]
    bean.destroyMethod = 'destroy' // Sets the destruction method to 'destroy'. [destroy-method]
    bean.scope = 'request'         // Sets the scope of the bean. [scope]
    dataSource = dataSource
    hibernateProperties = [ "hibernate.hbm2ddl.auto":"create-drop",
                            "hibernate.show_sql":true  ]
}

括号中的字符串对应于Spring XML定义中相应的bean 属性名。

 

在Spring MVC中使用BeanBuilder

如果想在Spring MVC中使用BeanBuilder，你必须确保grails-spring-<version>.jar 包含在classpath中. 还要在/WEB-INF/web.xml文件中做如下设置：

 

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.groovy</param-value>
</context-param>
<context-param>
    <param-name>contextClass</param-name>
    <param-value>org.codehaus.groovy.grails.commons.spring.GrailsWebApplicationContext</param-value>
</context-param>

然后在创建 /WEB-INF/applicationContext.groovy文件并配置如下:

 

beans {
        dataSource(org.apache.commons.dbcp.BasicDataSource) {
        driverClassName = "org.hsqldb.jdbcDriver"
        url = "jdbc:hsqldb:mem:grailsDB"
        username = "sa"
        password = ""
    }
}

 

从文件系统中加载bean定义

你可以使用BeanBuilder并使用下面的语法 来加载在外部Groovy脚本中定义的bean：

 

def bb = new BeanBuilder()
bb.loadBeans("classpath:*SpringBeans.groovy")
def applicationContext = bb.createApplicationContext()

这里BeanBuilder 将加载在classpath中以SpringBeans.groovy结尾的Groovy文件并将它们解析成bean的定义.这里是一个范例脚本文件：

 

beans {
    dataSource(BasicDataSource) {
        driverClassName = "org.hsqldb.jdbcDriver"
        url = "jdbc:hsqldb:mem:grailsDB"
        username = "sa"
        password = ""
    }
    sessionFactory(ConfigurableLocalSessionFactoryBean) {
        dataSource = dataSource
        hibernateProperties = [ "hibernate.hbm2ddl.auto":"create-drop",
                                "hibernate.show_sql":true  ]
    }
}

 

绑定变量

如果从脚本中加载bean，可以通过创建Groovy Binding对象来实现绑定:

 

def binding = new Binding()
binding.foo = "bar"

def bb = new BeanBuilder()
bb.binding = binding
bb.loadBeans("classpath:*SpringBeans.groovy")

def ctx = bb.createApplicationContext()

14.4 BeanBuilder DSL

使用构建器参数

可以通过在bean的class和最后一个closure之间定义的方法来定义构建器参数: 

bb.beans {
    exampleBean(MyExampleBean, "firstArgument", 2) {
        someProperty = [1,2,3]
    }
}

 

配置 BeanDefinition (使用工厂方法)

传给closure的第一个参数是一个bean配置对象引用,你可以使用它来配置工厂方法，调用 AbstractBeanDefinition 的方法:

 

bb.beans {
    exampleBean(MyExampleBean) { bean ->
        bean.factoryMethod = "getInstance"
        bean.singleton = false
        someProperty = [1,2,3]
    }
}

你也可以通过bean 定义方法的返回值来配置bean:

 

bb.beans {
    def example = exampleBean(MyExampleBean) {
        someProperty = [1,2,3]
    }
    example.factoryMethod = "getInstance"
}

 

使用工厂bean（Factory beans）

Spring提供了工厂bean的概念，即bean不是从class创建，而是由这些工厂创建 defines the concept of factory beans and often a bean is created not from a class, but from one of these factories. 在这种情况下bean没有class，你必须将工厂bean的名字传给定义的bean:

 

bb.beans {
    myFactory(ExampleFactoryBean) {
        someProperty = [1,2,3]
    }
    myBean(myFactory) {
        name = "blah"
    }
}

注意：上面的例子中我们传递的是 myFactory bean而不是一个clas. 另一个常见的需求是提供调用工厂bean的工厂方法名，可以用下面的Groovy语法做到这一点：

 

bb.beans {
    myFactory(ExampleFactoryBean) {
        someProperty = [1,2,3]
    }
    myBean(myFactory:"getInstance") {
        name = "blah"
    }
}

这里 ExampleFactoryBean 的 getInstance会被调用来创建myBean bean.

 

运行时创建 bean的引用

有时只有在运行是才知道需要创建的bean的名字. 在这种情况情况下你可以使用字符串替换来实现动态调用:

 

def beanName = "example"
bb.beans {
    "${beanName}Bean"(MyExampleBean) {
        someProperty = [1,2,3]
    }
}

在这个例子中，使用早先定义的 beanName 变量来调用bean.

另外, 可使用ref来动态引用在运行时才知道的bean的名字，如下面的代码：

 

def beanName = "example"
bb.beans {
    "${beanName}Bean"(MyExampleBean) {
        someProperty = [1,2,3]
    }
    anotherBean(AnotherBean) {
        example = ref("${beanName}Bean")
    }
}

这里AnotherBean属性通过运行时对 exampleBean的引用来设置 . 也可以通过 ref 来引用在父 ApplicationContext定义的bean， ApplicationContext在 BeanBuilder的构建器中提供:

 

ApplicationContext parent = ...//
der bb = new BeanBuilder(parent)
bb.beans {
    anotherBean(AnotherBean) {
        example = ref("${beanName}Bean", true)
    }
}

这里第二个参数 true 指定了在父ApplicationContext中查找bean的引用.

 

使用匿名内部bean

你可以通过将属性块付给bean的一个属性来使用匿名内部bean，这个属性块提供一个bean的类型参数:

 

bb.beans {
    marge(Person.class) {
        name = "marge"
        husband =  { Person p ->
            name = "homer"
            age = 45
            props = [overweight:true, height:"1.8m"]
        }
        children = [bart, lisa]
    }
    bart(Person) {
        name = "Bart"
        age = 11
    }
    lisa(Person) {
        name = "Lisa"
        age = 9
    }
}

在上面的例子中我们将marge bean的husband属性 赋值一个属性块（参数类型是Person）的方式创建一个内部bean引用. 如果你有一个工厂bean你也可以忽略类型参数，直接使用传进进来的bean的定义：

 

bb.beans {
    personFactory(PersonFactory.class)
    marge(Person.class) {
        name = "marge"
        husband =  { bean ->
            bean.factoryBean = "personFactory"
            bean.factoryMethod = "newInstance"
            name = "homer"
            age = 45
            props = [overweight:true, height:"1.8m"]
        }
        children = [bart, lisa]
    }
}

 

抽象bean和父子bean定义

要创建一个抽象bean，定义一个没有class 的bean：

 

class HolyGrailQuest {
    def start() { println "lets begin" }
}
class KnightOfTheRoundTable {
    String name
    String leader
    KnightOfTheRoundTable(String n) {
        this.name = n
    }
    HolyGrailQuest quest
    def embarkOnQuest() {
        quest.start()
    }
}

def bb = new grails.spring.BeanBuilder()
bb.beans {
    abstractBean {
        leader = "Lancelot"
    }
    …
}

这里定义了一个抽象bean，这个bean有一个属性 leader，属性值为 "Lancelot". 要使用抽象bean，只要将它设为要定义的bean的父即可：

 

bb.beans {
    …
    quest(HolyGrailQuest)
    knights(KnightOfTheRoundTable, "Camelot") { bean ->
        bean.parent = abstractBean
        quest = quest
    }
}

 

当使用父bean时，你必须在设置其他属性前设置parent属性!

如果你要定义一个具有class的抽象bean，可以这样:

 

def bb = new grails.spring.BeanBuilder()
bb.beans {
    abstractBean(KnightOfTheRoundTable) { bean ->
        bean.'abstract' = true
        leader = "Lancelot"
    }
    quest(HolyGrailQuest)
    knights("Camelot") { bean ->
        bean.parent = abstractBean
        quest = quest
    }
}

上面例子中我们创建了抽象 KnightOfTheRoundTable 并将它的参数设为abstract. 接下来我们定义了一个knights bean，没有定义它的class，而是继承父bean中定义的class。

 

使用 Spring命名空间

从Spring 2.0开始，通过XML命名空间可以更方便的使用Spring的各种特性. 如果使用 BeanBuilder， 你可以先声明所要使用的Spring命名空间:

 

xmlns context:"http://www.springframework.org/schema/context"

然后调用与命名空间名称和属性匹配的方法:

 

context.'component-scan'( 'base-package' :"my.company.domain" )

通过Spring的命名空间可以做很多有用的事，比如查找JNDI资源:

 

xmlns jee:"http://www.springframework.org/schema/jee"

jee.'jndi-lookup'(id:"dataSource", 'jndi-name':"java:comp/env/myDataSource")

上面的例子通过查找JNDI创建一个 dataSourcebean对象. 通过Spring命名空间，你可以在BeanBuilder中直接访问Spring AOP功能比如下面的代码:

 

class Person {
 int age;
 String name;
 void birthday() {
      ++age;
 }
}
class BirthdayCardSender {
   List peopleSentCards = []
   public void onBirthday(Person person) {
      peopleSentCards << person
   }
}

你可以定义一个AOP aspect pointcut来监测对 birthday() 方法的所有调用:

 

xmlns aop:"http://www.springframework.org/schema/aop"
fred(Person) { 
 name = "Fred" 
 age = 45 
}
birthdayCardSenderAspect(BirthdayCardSender)

aop { 
   config("proxy-target-class":true) { 
       aspect( id:"sendBirthdayCard",ref:"birthdayCardSenderAspect" ) { 
          after method:"onBirthday", pointcut: "execution(void ..Person.birthday()) and this(person)" 
       } 
   } 
}

14.5 属性占位符配置

通过扩展的Spring的PropertyPlaceholderConfigurer，Grails支持属性占位符配置，这和 外部配置配合使用非常有用。 .

Settings defined in either ConfigSlurper scripts of Java properties files can be used as placeholder values for Spring configuration in grails-app/conf/spring/resources.xml. For example given the following entries in grails-app/conf/Config.groovy (or an externalized config):

 

database.driver="com.mysql.jdbc.Driver"
database.dbname="mysql:mydb"

接着在 resources.xml中用${..}语法定义占位符：

 

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name="driverClassName"><value>${database.driver}</value></property>
   <property name="url"><value>jdbc:${database.dbname}</value></property>
 </bean>

14.6 属性重载

通过扩展的Spring PropertyOverrideConfigurer，Grails提供了对属性重载配置的支持， 外部配置配合使用非常有用。 .

你可以提供一个 ConfigSlurper脚本文件，该文件中定义了一个 beans 属性块，属性块中定义的属性值会覆盖bean中定义的属性值:

 

beans {
   bookService.webServiceURL = "http://www.amazon.com"
}

重载的属性应用在Spring ApplicationContext 创建之前. 格式如下:

 

[bean name].[property name] = [value]

你也可以提供一个常规的Java属性文件，属性文件中的每个条目加上beans前缀:

 

beans.bookService.webServiceURL=http://www.amazon.com
相关标签： Grails Spring Bean Groovy Hibernate

上一篇： 实战 Groovy: Groovy 的腾飞

下一篇： javascript计时器事件使用详解_基础知识

推荐阅读