精华内容
下载资源
问答
  • Grails

    2021-01-06 19:48:13
    入门 安装SDKMAN ... source "$HOME/.sdkman/...SDKMAN安装最新版本的Grails sdk install grails 4.0.6 gradle安装 https://gradle.org/releases/ 创建一个应用 grails create-app helloworld Hello .

    入门

    安装SDKMAN

    curl -s "https://get.sdkman.io" | bash

     

    source "$HOME/.sdkman/bin/sdkman-init.sh"
    sdk version

    下载Gradle

    https://gradle.org/releases/

    下载Grails

    https://github.com/grails/grails-core/releases

    配置环境变量

    export GRADLE_HOME=/Users/fanshaorong/Desktop/Program/gradle-6.7.1
    export GRAILS_HOME=/Users/fanshaorong/Desktop/Program/grails-3.3.12
    export PATH=$PATH:$GRADLE_HOME/bin:$GRAILS_HOME/bin

    gradle -v

    grails -version

    创建一个应用

    grails create-app helloworld

    Hello Wrold

    > cd helloworld
    > grails

    create-controller hello

    HelloController.groovy

    package helloworld
    
    class HelloController {
    
        def index() {
            render "Hello World!"
        }
    }
    

    run-app

    http://localhost:8080/

    http://localhost:8080/hello/index

    stop-app

     

    展开全文
  • grails

    2012-11-12 07:37:48
    grails-2.1.zip.001
  • Grails Grails Grails

    2009-05-19 17:34:32
    Grails Grails Grails Grails Grails
  • grails-app下 1、获取所有的domainclass GrailsApplication grailsApplication //获取配置信息 grailsApplication.config.getProperty('foo.bar.hello') grailsApplication.config.database.driver //获取应用...

    grails-app下

    1、获取所有的domainclass

    GrailsApplication grailsApplication
    //获取配置信息
    grailsApplication.config.getProperty('foo.bar.hello')
    grailsApplication.config.database.driver
    //获取应用版本信息
    grailsApplication.metadata.getApplicationVersion()
    //获取grails版本信息
    grailsApplication.metadata.getGrailsVersion()
    //获取带Controller的所有类名称
    grailsApplication.getArtefacts('Controller')*.name
    //获取所有类信息
    grailsApplication.allClasses
    //获取所有controoler
    grailsApplication.controllerClasses
    //获取所有domain
    grailsApplication.domainClasses
    
    //判断是否是controller
    grailsApplication.isControllerClass(org.example.MyGreatController)
    
    
    
    
    

     

    src下

    //获取配置信息
    Holders.grailsApplication.config.getProperty('foo.bar.hello')
    Holders.grailsApplication.config.database.driver
    //获取应用版本信息
    Holders.grailsApplication.metadata.getApplicationVersion()
    //获取grails版本信息
    Holders.grailsApplication.metadata.getGrailsVersion()
    //获取带Controller的所有类名称
    Holders.grailsApplication.getArtefacts('Controller')*.name
    //获取所有类信息
    Holders.grailsApplication.allClasses
    //获取所有controoler
    Holders.grailsApplication.controllerClasses
    //获取所有domain
    Holders.grailsApplication.domainClasses
    
    //判断是否是controller
    Holders.grailsApplication.isControllerClass(org.example.MyGreatController)
    
    //获取RedisService
    Holders.grailsApplication.mainContext.getBean(RedisService.class)
    
    
    
    
    
    def bookClass = grailsApplication.classLoader.loadClass("Book")
    [book: bookClass.newInstance()]
    展开全文
  • grails框架

    2018-09-03 15:28:13
    grails的插件系统也是其亮点之一。首先,和rails,django等web框架类似,基于微内核的思想,插件(可重用模块)是框架的一等公民。grails除了核心模块以外的功能几乎都是通过插件方式实现的。实际上,一个grails插件...
  • <p>The Hibernate plug-in that comes with grails 2.4.0 (org.grails.plugins:hibernate4:4.3.5.3) has a dependency on grails-bootstrap:2.3.8 instead of grails-bootstrap:2.4.0. <p>This causes internal ...
  • 简单的方法来访问Grails文档。 Grails Doc扩展可以帮助您使用浏览器地址栏中的grails版本直接访问特定的Grails文档。 ===用法=== 在浏览器地址栏中输入“gdoc”,然后点击标签或空格来初始化扩展名。 输入完整的...
  • grails java_Grails

    2021-03-19 08:24:42
    十二、Grails如今的Java Web开发对于需求来说已经变得过于复杂。当今众多Java领域的Web开发框架不仅使用复杂,而且并没有很好的遵循Don’t Repeat Yourself(DRY)原则。像Rails,Django和TurboGears这样的动态框架在...

    十二、Grails

    如今的Java Web开发对于需求来说已经变得过于复杂。当今众多Java领域的Web开发框架不仅使用复杂,而且并没有很好的遵循Don’t Repeat Yourself(DRY)原则。像Rails,Django和TurboGears这样的动态框架在Web开发领域开辟了一条新的道路,Grails基于这些概念之上,采用动态方法减小了Java平台上进行Web开发的复杂度,不过与那些框架不同的是,Grails是构建在Spring和Hibernate等Java已有的技术之上的。

    fa78bc549db81cc47c4ffe33f4a83268.png

    Grails

    Grails是一个full-stack框架,它借助于核心技术与相关的插件来解决Web开发中方方面面的问题,其中包括: 易于使用的基于Hibernate的对象-关系映射(ORM)层 称为Groovy Server Pages的表现层技术 基于Spring MVC的控制器层 构建于Gant 上的命令行脚本运行环境 内置Jetty服务器,不用重新启动服务器就可以进行重新加载 利用内置的Spring 容器实现依赖注入 基于Spring的MessageSource核心概念,提供了对国际化的支持 基于Spring事务抽象概念,实现事务服务层 借助于功能强大的Groovy动态语言和领域特定语言,以上那些特性变得非常易用。

    十三、Struts

    Struts是开源软件。使用Struts的目的是为了帮助我们减少在运用MVC设计模型来开发Web应用的时间。如果我们想混合使用Servlets和JSP的优点来建立可扩展的应用,Struts是一个不错的选择。

    a6c708f89c7099b23b8563178e99ea6b.png

    struts

    框架

    Struts框架具有组件的模块化,灵活性和重用性的优点,同时简化了基于MVC的web应用程序的开发。

    Struts可以清晰地区分控制,事务逻辑和外观,从而简化了开发应用程序的过程。Struts提供的类使得开发工作更加简单,这些类包括:

    ●控制程序流程的类

    ●实现和执行程序事务逻辑的类

    ●自定义的标记库使得创建和验证HTML表单更加容易

    展开全文
  • Grails in Action

    2019-06-20 15:21:34
    Grails in Action Grails in Action Grails in Action
  • Grails 7280

    2021-01-06 21:00:20
    <div><p>Just fixed the issue behind the mentioned behavior in the ticket http://jira.codehaus.org/browse/GRAILS-7280</p> <p>Check on empty string was missing....grails/grails-core</p></div>
  • <div><p>fixes for https://jira.grails.org/browse/GRAILS-11864 https://jira.grails.org/browse/GRAILS-11863</p><p>该提问来源于开源项目:grails/grails-core</p></div>
  • Grails Grails和 Spring

    2018-06-07 13:32:51
    这一节适合于高级用户, Spring 框架,和想通过 插件开发来配置Grails的开发人员。14.1 Grails内部实现实际上Grails是变相的 Spring MVC 应用. Spring MVC是Spring框架内置的 MVC web开发框架.虽然从易用性来说...

    这一节适合于高级用户, 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实例, 它在 doWithSpringbeans块中都隐式存在.

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

    实际上,每个方法调用( dataSourcesessionFactory 调用) 都映射到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"
        }
    }

    这里 ExampleFactoryBeangetInstance会被调用来创建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, ApplicationContextBeanBuilder的构建器中提供:

     

    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前缀:

     

    展开全文
  • Grails中的所有内容,从构建脚本到单个工件(例如域类和控制器),都在应用程序生命周期的关键时刻抛出事件。 在本系列的Mastering Grails中 ,您将学习如何设置侦听器以捕获这些事件并以自定义行为对其做出React。...
  • grails_Grails AJAX示例

    2020-04-23 19:05:52
    grails 早期,Grails的新手会遇到缺少该框架附带的工作示例的情况。 示例和文档的好地方包括Grails文档和博客。 Ajax是Grails内置支持的功能之一。 一旦人们“熟悉”了Grails的基础知识,他们通常就希望转向Ajax...
  • Grails标签

    2015-08-11 15:58:55
    Grails标签 主要介绍了grails的标签的一个帮助文档
  • grails开发

    2015-01-06 11:32:08
    grails开发关于grails入门指南的例子进行分析
  • grails_Grails最佳做法

    2020-07-07 16:42:55
    grails 我在IntelliGrape工作,该公司专门从事Groovy&Grails开发。 本文是Grails项目遵循的最佳实践的基本列表,这些列表从邮件列表,Stack Overflow,博客, 播客以及IntelliGrape的内部讨论中收集。 它们分为控制...
  • Environment: Windows 7, java 1.6.0_26, grails-2.0.0.BUILD-SNAPSHOT Version: Not Specified Migrated From: http://jira.grails.org/browse/GRAILS-7939</p> <p>Latest Grails distribution, taken from hudson ...
  • grails3.3.0_Grails 1.3

    2020-06-17 06:17:30
    Grails 1.3的第一个候选版本现在可用。 Grails是基于Java和Groovy构建的动态Web应用程序框架。 它旨在提供基于约定的开发,同时利用Java开发人员使用多年的API的现有知识。 Grails 1.3 RC 1引入了对Groovy 1.7的...
  • 设置GRAILS_HOME环境变量以指向提取的下载文件的根目录,并将GRAILS_HOME/bin添加到您的可执行文件PATH 。 然后在外壳中,键入以下内容: grails create-app sampleapp cd sampleapp grails run-app 要构建Grails...
  • 一、环境配置:2、设置环境变量:JAVA_HOME,GROOVY_HOME,GRAILS_HOME。设置PATH:把grails_home及groovy_home中的bin目录加入到path中。3、设置好上面的路径,验证一下是否配置成功,打开cmd命令行,输入”grails”...
  • <div><p>Original Reporter: kaaloo Environment: Not Specified Version: Not Specified Migrated From: http://jira.grails.org/browse/GRAILS-3890</p> <p>mvn grails:war in a new ...grails/grails-core</p></div>
  • Grails学习-源码

    2021-02-12 14:12:04
    Grails学习
  • grails 为了加强我们新Grails应用程序中的安全性,我着手实现了Spring Security Plugin 。 使用标准的用户名/密码进行安装和运行非常简单,因为所有这些都由插件自动连接。 这解决了我一半的问题,但是我们还需要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,926
精华内容 2,770
关键字:

grails