Groovy & Grails for Java Developers

Transcript

1. Groovy and Grails for Java developers Peter Ledbrook SpringSource t:

   @pledbrook g: +PeterLedbrook e: [email protected]

2. What is Groovy? • A dynamic language for the JVM

   – ...with a Java-like syntax – ...and optional static types • Uses and extends the JDK • Write scripts as well as classes • Seamless integration with Java – ...call Java from Groovy – ...or call Groovy from Java – ...all in the same project • Great IDE support in IntelliJ and Eclipse – NetBeans also has Groovy (& Grails support)

3. 3 GroovyBean syntax

4. 4 Define properties as fields...

5. 5 ...and initialize them on construction

6. 6 Define a getter method...

7. 7 ...and still use property syntax to access it

8. 8

9. 9 Properties implicitly have getter and setter methods

10. 10

11. 11 Use the @Immutable annotation...

12. 12 ...and typed properties...

13. 13 ...to get a standard constructor...

14. 14 ...and make instances immutable

15. 15

16. 16

17. 17 Use single or double-quotes for strings

18. 18 Double quotes allow for embedded expressions

19. 19 Use array syntax to access characters of a string

20. 20

21. 21 Array syntax with ranges extracts substrings

22. 22 and can even allow for reversing of the substring

23. 23 Triple quotes for multi-line strings

24. 24

25. 25 Java doubles are not exact

26. 26

27. 27 Java solution with BigDecimal is ugly

28. 28 Groovy uses BigDecimal by default and provides operator support

29. 29 for precise floating-point calculations

30. 30

31. 31 List literals

32. 32 Extra collection methods for convenience

33. 33

34. 34 Easy map iteration with key and value as separate

    arguments

35. 35

36. 36 Collection filtering with closures

37. 37

38. 38 Map one collection to another by applying a function

    to each element

39. 39 Same collection, but each element has a value of

    3 less than before

40. 40

41. 41 Slashy string literals for use with regular expressions

42. 42 Backslash in regex does not need escaping

43. 43 Iterate over matches...

44. 44 ...and use array syntax to access the match groups

45. 45 Literal for compiled patterns

46. 46 Generate XML from Groovy code

47. 47 Methods with closures become nested elements

48. 48

49. 49 Named arguments become attributes

50. 50

51. 51 Because it’s Groovy code, use conditions and loops

52. 52

53. 53 Easy XML parsing

54. 54 Parse and create a DOM-like object

55. 55 And use properties, array-syntax, etc. to access elements and

    content

56. 56

57. 57

58. 58 ‘@’-syntax for accessing attributes

59. 59

60. 60 Even incorporate filtering

61. Where to use Groovy • Scripts – especially with groovyserv

    – cross-platform • Tests – syntax more expressive – Spock for BDD • Java application plugins/scripting – GroovyShell – GroovyClassLoader • Domain Specific Languages • Higher-level application development

62. Scripting with SQL 62

63. Scripting with SQL 63 Create a new Sql instance with

    JDBC connection details

64. Scripting with SQL 64 Easy querying and processing or results

65. Scripting with SQL 65 Easy, safe updates with GStrings

66. 66 Scripting with XML content

67. 67 Scripting with XML content Grab content from URLs with

    automatic closing of the stream

68. 68 Scripting with XML content Then hook into other Groovy

    features for processing the content

69. 69 Scripting with XML content Easy writing to files, with

    safe file stream close

70. 70 Scripting with XML content Print to the new file

71. 71 Scripting with XML content Iteration over elements in the

    XML

72. Scripting with GORM 72

73. Scripting with GORM 73 Use @Grab to include external dependencies

74. Scripting with GORM 74 Define a domain class...

75. Scripting with GORM 75 ...and use GORM/MongoDB to save data

76. Spock • BDD testing framework • Encourages simple test structure

    • ...and documented tests • given...when...then • + data-driven tests! • Can run via JUnit test runner 76 http://code.google.com/p/spock/ http://meetspock.appspot.com/

77. 77 Using Spock

78. Implementing a DSL 78

79. Groovy in Maven 79

80. Groovy in Maven 80

81. Groovy in Maven 81

82. • Grails for Swing applications • MVC model • SwingBuilder

    for views 82 application(title: 'DemoConsole', pack: true, locationByPlatform: true) { panel(border: emptyBorder(6)) { borderLayout() scrollPane(constraints: CENTER) { textArea( text: bind(target: model, targetProperty: 'scriptSource'), enabled: bind {model.enabled}, columns: 40, rows: 10) } } } http://griffon.codehaus.org/

83. Gradle • Build tool with built-in dependency management • Conventions

    through plugins • Multi-project support • Full access to tasks and dependency tree • Easy to write your own tasks – either in the build file – or via Groovy/Java classes 83 http://www.gradle.org/

84. • Parallel processing for Groovy • Actors library making full

    use of closures 84 @Grab(group='org.codehaus.gpars', module='gpars', version='0.11') import groovyx.gpars.GParsPool GParsPool.withPool { def animals = ['dog', 'ant', 'cat', 'whale'] println(animals.anyParallel {it ==~ /ant/} ? 'Found an ant' : 'No ants found') println(animals.everyParallel {it.contains('a')} ? 'All animals contain a' : 'Some animals can live without an a') } http://gpars.codehaus.org/

85. Try it out! 85 http://groovyconsole.appspot.com/

86. What is Grails? • Rapid Web Application Development Framework –

    for the JVM – with first-class Java integration • Inspired by Ruby on Rails, Django and others – Convention over Configuration – Don’t Repeat Yourself (DRY) 86

87. Grails What is Grails? 87 Build Web MVC GSP (Views)

    GORM (Data Access) Doc Engine Servlet Container Test Support Database I18n

88. Grails What is Grails? 88

89. What is Grails? 89 Web Controllers The Domain Model Business

    Logic Custom View Tags Views & Layouts Libraries (JARs) Additional Sources Web Resources i18n bundles Build Commands Tests

90. Say bye-bye to the plumbing! 90

91. Demo

92. Enterprise requirements 92 Web App Messaging Legacy Databases Services JEE

    Is this a problem for Grails apps?

93. Build 93 • Remember the Grails project structure? – add

    in build events and... Can’t build natively with other build tools! Grails Build System Ant Gradle Maven

94. Dependency DSL grails.project.dependency.resolution = { inherits "global" log "warn" repositories

    { grailsHome() mavenCentral() mavenRepo "http://localhost:8081/..." } ... } 94

95. Dependency DSL grails.project.dependency.resolution = { inherits "global" log "warn" ...

    dependencies { runtime "mysql:mysql-connector-java:5.1.17" test "org.gmock:gmock:0.8.1" ... } plugins { compile ":spring-security-core:1.2.7" ... } } 95

96. ‘Legacy’ Databases • Grails can create a database from your

    domain model... • ...but what if you don’t own the database? – DBA determines structure – Company conventions – Existing ‘legacy’ database 96

97. • No existing domain model • Schema not too far

    off the beaten track 97 Option 1: Custom ORM mapping class Book { ... static mapping = { table "books" title type: "books" author column: "author_ref" } }

98. • Existing Java/JPA domain model Option 2: JPA annotations 98

    grails-app/conf/hibernate/hibernate.cfg.xml <?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE ...> <hibernate-configuration> <session-factory> <mapping class="org.ex.Book"/> <mapping class="org.ex.Author"/> ... </session-factory> </hibernate-configuration>

99. • You have Java model + Hibernate mapping files •

    Schema is way off the beaten track 99 grails-app/conf/hibernate/hibernate.cfg.xml Option 3: Hibernate XML Mappings <?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE ...> <hibernate-configuration> <session-factory> <mapping resource="org.ex.Book.hbm.xml"/> <mapping resource="org.ex.Author.hbm.xml"/> ... </session-factory> </hibernate-configuration>

100. constraints = { title blank: false, unique: true ... }

     Constraints Given domain class: Then: org.example.myapp.domain.Book src/java/org/example/myapp/domain/BookConstraints.groovy 100

101. • GORM layer over JPA • Use your own JPA

     provider • Useful for cloud services that only work with JPA, not Hibernate 101 Option 4: GORM JPA Plugin

102. Database Migration Plugin 102 Pre-production, Hibernate ‘update’ or ‘create-drop’ dbm-generate-changelog

     dbm-changelog-sync Change domain model dbm-gorm-diff dbm-update

103. Reverse Engineering Plugin 103 class Person { String name Integer

     age ... }

104. Grails is Spring • Spring MVC under the hood •

     Grails provides many useful beans – e.g. grailsApplication • Define your own beans! – resources.xml/groovy – In a plugin 104

105. Example import ... beans = { credentialMatcher(Sha1CredentialsMatcher) { storedCredentialsHexEncoded =

     true } sessionFactory(ConfigurableLocalSessionFactoryBean) { dataSource = ref("dataSource") hibernateProperties = [ "hibernate.hbm2ddl.auto": "create-drop", "hibernate.show_sql": true ] } } 105

106. Enterprise Integration • Spring opens up a world of possibilities

     – Spring Integration/Camel – Messaging (JMS/AMQP) – ESB – RMI, HttpInvoker, etc. • Web services & REST 106

107. Grails Plugins • Routing • JMS, RabbitMQ • CXF, Spring-WS,

     WS-Client • REST 107

108. Summary • Various options for integrating Grails with: – Development/build

     – Deployment processes • Works with many external systems – Solid support for non-Grailsy DB schemas – Flexible messaging & web service support 108

109. More info • w: http://grails.org/ • f: http://grails.org/Mailing+Lists • e:

     [email protected] • t: pledbrook • b: http://blog.springsource.com/author/peter-ledbrook/ 109

110. Q&A