Gajanan Koram

Maven in 5 Minutes

2013-03-06T01:39:00.001-08:00

Built by Maven
Maven in 5 Minutes
Installation

Maven is a Java tool, so you must have Java installed in order to proceed.

First, download Maven and follow the installation instructions. After that, type the following in a terminal or in a command prompt:

mvn --version

It should print out your installed version of Maven, for example:

Maven version: 2.0.8
Java version: 1.5.0_12
OS name: "windows 2003" version: "5.2" arch: "x86" Family: "windows"

Depending upon your network setup, you may require extra configuration. Check out the Guide to Configuring Maven if necessary.
Creating a Project

On your command line, execute the following Maven goal:

mvn archetype:create -DgroupId=com.mycompany.app -DartifactId=my-app

If you have just installed Maven, it may take a while on the first run. This is because Maven is downloading the most recent artifacts (plugin jars and other files) into your local repository. You may also need to execute the command a couple of times before it succeeds. This is because the remote server may time out before your downloads are complete. Don't worry, there are ways to fix that.

You will notice that the create goal created a directory with the same name given as the artifactId. Change into that directory.

cd my-app

Under this directory you will notice the following standard project structure.

my-app
|-- pom.xml
`-- src
|-- main
| `-- java
| `-- com
| `-- mycompany
| `-- app
| `-- App.java
`-- test
`-- java
`-- com
`-- mycompany
`-- app
`-- AppTest.java

The src/main/java directory contains the project source code, the src/test/java directory contains the test source, and the pom.xml is the project's Project Object Model, or POM.
The POM

The pom.xml file is the core of a project's configuration in Maven. It is a single configuration file that contains the majority of information required to build a project in just the way you want. The POM is huge and can be daunting in its complexity, but it is not necessary to understand all of the intricacies just yet to use it effectively. This project's POM is:

4.0.0
com.mycompany.app
my-app
jar
1.0-SNAPSHOT
Maven Quick Start Archetype
http://maven.apache.org

junit
junit
3.8.1
test

What did I just do?

You executed the Maven goal archetype:create, and passed in various parameters to that goal. The prefix archetype is the plugin that contains the goal. If you are familiar with Ant, you may concieve of this as similar to a task. This goal created a simple project based upon an archetype. Suffice it to say for now that a plugin is a collection of goals with a general common purpose. For example the jboss-maven-plugin, whose purpose is "deal with various jboss items".
Build the Project

mvn package

The command line will print out various actions, and end with the following:

...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2 seconds
[INFO] Finished at: Thu Oct 05 21:16:04 CDT 2006
[INFO] Final Memory: 3M/6M
[INFO] ------------------------------------------------------------------------

Unlike the first command executed (archetype:create) you may notice the second is simply a single word - package. Rather than a goal, this is a phase. A phase is a step in the build lifecycle, which is an ordered sequence of phases. When a phase is given, Maven will execute every phase in the sequence up to and including the one defined. For example, if we execute the compile phase, the phases that actually get executed are:

1. validate
2. generate-sources
3. process-sources
4. generate-resources
5. process-resources
6. compile

You may test the newly compiled and packaged JAR with the following command:

java -cp target/my-app-1.0-SNAPSHOT.jar com.mycompany.app.App

Which will print the quintessential:

Hello World!

Running Maven Tools
Maven Phases

Although hardly a comprehensive list, these are the most common default lifecycle phases executed.

* validate: validate the project is correct and all necessary information is available
* compile: compile the source code of the project
* test: test the compiled source code using a suitable unit testing framework. These tests should not require the code be packaged or deployed
* package: take the compiled code and package it in its distributable format, such as a JAR.
* integration-test: process and deploy the package if necessary into an environment where integration tests can be run
* verify: run any checks to verify the package is valid and meets quality criteria
* install: install the package into the local repository, for use as a dependency in other projects locally
* deploy: done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects.

There are two other Maven lifecycles of note beyond the default list above. They are

* clean: cleans up artifacts created by prior builds

* site: generates site documentation for this project

Phases are actually mapped to underlying goals. The specific goals executed per phase is dependant upon the packaging type of the project. For example, package executes jar:jar if the project type is a JAR, and war:war is the project type is - you guessed it - a WAR.

An interesting thing to note is that phases and goals may be executed in sequence.

mvn clean dependency:copy-dependencies package

This command will clean the project, copy dependencies, and package the project (executing all phases up to package, of course).
Generating the Site

mvn site

This phase generates a site based upon information on the project's pom. You can look at the documentation generated under target/site.
Conclusion

We hope this quick overview has piqued your interest in the versitility of Maven. Note that this is a very truncated quick-start guide. Now you are ready for more comprehensive details concerning the actions you have just performed. Check out the Maven Getting Started Guide.
© 2002-2010 The Apache Software Foundation - Privacy Policy

Creating our First Grails Application (e.g. racetrack)

2010-03-11T01:49:00.000-08:00

command prompt> grails create-app racetrack
command prompt> cd racetrack
command prompt\racetrack> grails run-app

Open your browser to http://localhost:8080/racetrack/

Directory Structure

From this information, we can see that we’re basically working with two types of data –races and registrations – and that there’s a one-to-many relationship between those entities. That information will form the basis of our domain model, and the various data elements on the form will become the attributes of

our domain classes.

Create-Domain-Class

racetrack> grails create-domain-class Race

class Race {
String name
Date startDateTime
String city
String state
Float distance
Float cost
Integer maxRunners = 100000
static hasMany = [registrations:Registration]
}

racetrack> grails create-domain-class Registration

class Registration {
Race race
String name
Date dateOfBirth
String gender = 'F'
String emailAddress
String postalAddress
Date createdAt = new Date()
static belongsTo = Race
static optionals = ["postalAddress" ]
}

Relationship Counseling

One to Many Relationships
class Race {
//...
static hasMany =[registrations:Registration]
}

class Registration {
//...
Race race
static belongsTo = Race
}

create-controller

racetrack> grails create-controller Race

class RaceController {
//def index = { }
def scaffold = Race
}

racetrack> grails create-controller Registration

class RegistrationController {
def scaffold = Registration
}

racetrack> grails run-app
Open your browser to http://localhost:8080/racetrack/

Scaffolding
Grails has a scaffolding framework that generates applications with create, read, update, and delete (CRUD) functionality with very little code, allowing you to focus on defining the Groovy domain by creating classes with properties, behaviors, and constraints. At either runtime or development time, Grails can generate the controller behavior and GSP views associated with the domain classes for CRUD functionality. At the same time, it can even generate a database schema, including tables for each of the domain classes.

DataSource Configuration

dataSource {
pooled = true
driverClassName = "org.hsqldb.jdbcDriver" // "com.mysql.jdbc.Driver"
username = "sa“ // root
password = "“ // root
// dialect = "org.hibernate.dialect.MySQL5InnoDBDialect"
}
hibernate {
cache.use_second_level_cache=true
cache.use_query_cache=true
cache.provider_class='com.opensymphony.oscache.hibernate.OSCacheProvider'
}
environments {// environment specific settings
development {
dataSource {
dbCreate = "create-drop" // one of 'create', 'create-drop','update'
url = "jdbc:hsqldb:mem:devDB“ // "jdbc:mysql://localhost:3306/testdb"
}
}
test {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:mem:testDb"
}
}
production {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:file:prodDb;shutdown=true"
}
}
}

Note: For the mysql configuration uncommented dataSource properties for mysql

mysql> describe race;
+----------------+-------------+----+---+-------+---------------+-------------------
| Field | Type |Null | Key |Default | Extra |
+----------------+-------------+----+---+-------+---------------+------------
|id | bigint(20) | NO |PRI | NULL | auto_increment
|version | bigint(20) | NO | | | |
|distance | float | NO | | | |
|max_runners | int(11) | NO | | | |
|start_date_time| datetime | NO | | | |
|state | varchar(255) | NO | | | |
|cost | float | NO | | | |
|name | varchar(255) | NO | | | |
|city | varchar(255) | NO | | | |
+----------------+-------------+----+---+-------+---------------+------------

mysql> describe registration;
+----------------+-------------+----+---+-------+---------------+------------+------
| Field | Type |Null |Key |Default | Extra |
+----------------+-------------+----+---+-------+---------------+------------+------
|id | bigint(20) | NO |PRI | NULL | auto_increment
|date_of_birth | datetime | NO | | | |
|version | bigint(20) | NO | | | |
|gender | varchar(255) | NO | | | |
|postal_address | varchar(255) | YES | | NULL | |
|email_address | varchar(255) | NO | | | |
|created_at | datetime | NO | | | |
|race_id | bigint(20) | YES |MUL | NULL | |
|name | varchar(255) | NO | | | |
+-----------------+------------+----+---+-------+---------------+------------+------
9 rows in set (0.00 sec)

If database schema already exist , we can map table fields with our domain class

class Race {
//…
static hasMany = [registrations:Registration]
static mapping = {
table ‘race_tbl‘ // map existing table with domain class
columns { // map Columns
id column: 'OID‘
name column: ‘name’
startDateTime column: ‘cr_time’
city column: ‘city’
state column: ‘st’
distance column: ‘distance’
cost column: ‘prize’
}
}
}

Adding Custom constraints ::

class Race {
//...
static constraints = {
name(maxLength:50,blank:false)
//startDateTime(min:new Date())
city(maxLength:30,blank:false)
distance(min:3.1f,max:100f)
cost(min:0f,max:999.99f)
startDateTime(validator: {return (it > new Date())})
//custom validator
}
}

Grails creates a new controller instance for each request, and the
controller only lives long enough to process that request.
you can write your custom code by adding methods in controller and gsp pages to rendering the ouput result

Fun with URLs

http://localhost:8080/racetrack/race/show/2
class RaceController {
//... //View : racetrack/race/show
def show = {
[ race : Race.get( params.id ) ]
}
def save = {
def race = new Race()
race.properties = params
if(race.save()) {
redirect(action:show,id:race.id)
}
else {
render(view:'create',model:[race:race])
}
}
}

Grails Basic

2010-02-09T01:30:00.000-08:00

Web Framework inspired by RoR(Ruby On Rails)
Latest version is 1.1.1.
Based on open source technologies like Spring, Hibernate and SiteMesh
Grails = Spring MVC 2.5.1 + Hibernate 3 + SiteMesh2.3
Newbie's are unaware that Grails is full and full Spring!
Provides several commands to auto generate common requirements in a web app.
Comes bundled with HSQLDB and Jetty web Server
Focus is on rapid development and simplicity
Coding by convention paradigm
Reduce the need for configuration files and other boilerplate code
File names are important

Features

Rapid web application development

Follow spring MVC framework

-Clearly separates business, navigation and presentation logic Proven mechanism for building a thin, clean web-tier

Both gsp and jsp are supported.
AJAX Support

Supports prototype, YUI, DOJO
Use render method in your groovy code to render text, HTML, JSON

Has lots of plug-in already available like quartz, acegi , RichUi etc…

grails create-plugin !
grails install-plugin

Grails architecture

In Figure,
a web browser making a request to a Jetty web container. The container forwards the request on to a controller in a similar fashion to the standard MVC model. The controller may set or use data from a domain class (model). As all Grails domain classes are persistable through the GORM framework.

Ant Basic

2009-11-04T06:36:00.000-08:00

Ant Basic

Ant (originally an acronym for Another Neat Tool), is a build tool with special support for the Java programming language but can be used for just about everything. Ant is platform-independent; it is written purely in Java. Ant is particularly good at automating complicated repetitive tasks and thus is well suited for automating

Ant Installation

Configuration for Windows Environment

1. Download latest binary zip from http://jakarta.apache.org/ant/.
2. Unzip Binary in any folder, in my end it unzip on c:\
E.g. C:\apache-ant-1.7.0
3. Setting Environment variable: Right Click on My Computer ->Properties->Advanced tab->Environment variable->Create User variable

Variable	Value
ANT_HOME	C:\apache-ant-1.7.0
Path	%JAVA_HOME%\bin; %ANT_HOME%\bin; %ANT_HOME%\lib;

4. on command-line type c:\ant to verify proper configuration

Working with Ant

For typical Java Project building By Ant script

1. To create test project here is common folder and file
src: For project source files.
build.xml: ant script for clean/compile/create jar etc.. file
2. add a simple java class HelloWorld.java in src/com/myapp
package com.myapp;

public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
}
}
3. By default Ant uses build.xml as the name for a buildfile, so our .\build.xml would be:

<br />
<?xml version="1.0"?><br />
<project name="test" default="compile" basedir="."><br />
<property name="src" value="."/><br />
<property name="build" value="build"/><br />
<target name="init"><br />
<mkdir dir="${build}"/><br />
</target><br />
<target name="compile" depends="init"><br />
<br />
<javac srcdir="${src}" destdir="${build}"/><br />
</target><br />
</project><br />
<br />

Note: plz remove br tag

4. on command promt type c:testprj>ant compile
It will create a new folder named build, having the entire compile file from the source folder

Creating a jar-file

Creating a jar-file is not very difficult. But creating a startable jar-file needs more steps: create a manifest-file containing the start class, creating the target directory and archiving the files.

<br />
<!--
<?xml version="1.0"?><br />
<project name="test" default="compile" basedir="."><br />
<property name="src.dir"     value="src"/><br />
<property name="build.dir"   value="build"/><br />
<property name="classes.dir" value="${build.dir}/classes"/><br />
<property name="jar.dir"     value="${build.dir}/jar"/><br />
<property name="lib.dir"     value="lib"/><br />
<property name="main-class”  value="myapp.HelloWorld"/><br />
<br />
<path id="classpath"><br />
<fileset dir="${lib.dir}" includes="**/*.jar"/><br />
</path><br />
<br />
<target name="compile"><br />
<mkdir dir="${classes.dir}"/><br />
<javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="classpath"/><br />
<copy todir="${classes.dir}"><br />
<fileset dir="${src.dir}" excludes="**/*.java"/><br />
</copy><br />
</target><br />
<br />
<target name="jar" depends="init"><br />
<!-- Compile the java code --><br />
<mkdir dir="build/jar"/><br />
<jar destfile="${jar.dir}/HelloWorld.jar" basedir="${classes}"><br />
<manifest><br />
<attribute name="Main-Class" value="${main-class}"/><br />
</manifest><br />
</jar><br />
</target><br />
<target name="run"><br />
<java jar="${jar.dir}/HelloWorld.jar" fork="true"/><br />
</target><br />
</project><br />
<br />
--><br />
<br />

Note: plz remove br tag

Creating a War-file

for typical eclipse web project the folder structure is
testProject
-src : For Project source file
-WebContent
-- WEB-INF
---- lib : For compiled/output files produced (by Ant).
---- web.xml
-- META-INF
-- html/jsp/css/javascript files

to create a ant script add build.xml

<br />
<!-- 



<?xml version="1.0"?><br />
<br />
<project name="test-prj" basedir="." default="deploy"><br />
    <property name="src.dir"     value="src"/><br />
    <property name="build.dir"   value="build"/><br />
    <property name="classes.dir" value="${build.dir}/classes"/><br />
    <property name="web.dir"     value="WebContent"/><br />
    <property name="lib.dir"     value="${web.dir}/WEB-INF/lib"/><br />
    <property name="war.dir"   value="warfile"/><br />
    <property name="tomcat.dir"  value="C:\Server\jakarta-tomcat-5.5.9\webapps"/><br />
 <br />
    <path id="classpath"><br />
        <fileset dir="${lib.dir}" includes="**/*.jar"/><br />
    </path><br />
<br />
    <target name="clean"><br />
        <delete dir="${build.dir}"/><br />
     <delete dir="${war.dir}"/><br />
    </target><br />
<br />
    <target name="compile"><br />
        <mkdir dir="${classes.dir}"/><br />
        <javac srcdir="${src.dir}" destdir="${classes.dir}" classpathref="classpath"/><br />
  <copy todir="${classes.dir}"><br />
            <fileset dir="${src.dir}" excludes="**/*.java"/><br />
        </copy><br />
    </target><br />
 <br />
 <target name="unpack"><br />
  <unwar src="${war.dir}/${ant.project.name}.war" dest="${ant.project.name}" /><br />
 </target><br />
 <br />
 <target name="create"><br />
  <mkdir dir="${war.dir}"/><br />
  <war destfile="${war.dir}/${ant.project.name}.war" webxml="${web.dir}/WEB-INF/web.xml" update="true"><br />
   <classes dir="build\classes"/><br />
   <fileset dir="${web.dir}"><br />
    <exclude name="WEB-INF/web.xml"/><br />
   </fileset><br />
  </war><br />
 </target><br />
<br />
 <target name="copy"><br />
  <copy todir="${tomcat.dir}" overwrite="true"><br />
   <fileset dir="${war.dir}"><br />
    <include name="*.war"/><br />
   </fileset><br />
  </copy><br />
 </target><br />
 <br />
 <target name="deploy"><br />
  <antcall target="clean"/><br />
  <antcall target="compile"/><br />
  <antcall target="create"/><br />
  <antcall target="copy"/><br />
 </target><br />
<br />
</project><br />
<br />
<br />
--><br />

Note: plz remove br tag

Groovy On Grails setup on windows

2009-07-07T21:31:00.000-07:00

Groovy On Grails Configuration for Windows Environment

=> Download Java SE Development Kit (JDK 1.4.x or more ) installer for windows

( http://java.sun.com/javase/downloads/index.jsp)

=> Download Latest Version Groovy 1.5.x( http://groovy.codehaus.org) Binary Zip.

=> Download Latest Version Grails 1.1.x(http://www.grails.org) Binary Zip.

=> Install JDK

=> Unzip Binary in any folder, in my end it unzip on c:\installation.

Eg. c:\installation\groovy1.5.x

c:\installation\grails1.1.x

c:\Program Files\Java\ jdk1.5.9

=>Set Environment variable for Groovy on Grails and Java

Right Click on My Computer ->Properties->Advanced tab->Environment variable

Create User variable

Variable Value

JAVA_HOME c:\Program Files\Java\jdk1.5.9

GROOVY_HOME c:\installation\groovy1.5.x

GRAILS_HOME c:\installation\grails1.1.x

path %JAVA_HOME%\bin;%GROOVY_HOME%\bin;%GRAILS_HOME% \bin;%GRAILS_HOME%\ant\bin

=> Testing Configuration

Check with START->run->cmd . you will get the command Prompt.

Run c:\>javac : you will get the java option that means ur jdk is set for development.

Run c:\>grails help : you will get Grails command line artifacts for creating grails application it classes etc..

Examples:
grails dev run-app
grails create-app books

Available Targets (type grails help 'target-name' for more info):
grails bootstrap
grails bug-report
grails clean
grails compile
grails console
grails create-app
grails create-controller
grails create-domain-class
grails create-filters
grails create-integration-test
grails create-plugin
grails create-script
grails create-service
grails create-tag-lib
grails create-unit-test
grails doc
grails generate-all
grails generate-controller
grails generate-views
grails help
grails init
grails install-plugin
grails install-templates
grails list-plugins
grails package
grails package-plugin
grails plugin-info
grails release-plugin
grails run-app
grails run-war
grails schema-export
grails set-proxy
grails set-version
grails shell
grails stats
grails test-app
grails uninstall-plugin
grails upgrade
grails war

=> Grails Sample Applications using Scaffold.

Goto command prompt

c:\> grails create-app EMP

c:\>cd EMP

u ll see the Folder structure is created for grails project , it follows MVC design pattern,

so u can manage your code properly like we can separate thing, all presentation logic we keep in grails-app/view folder , we can add model class in grails-app/domain folder, controller class added to perform actions on http request/response keep in grails-app/Controller folder, grails provide good command line artifact to perform this action ...

u can simply run c:\EMP> grails run-app

and http://localhost:8080/EMP u will see the index page of create application..

added a domain class

c:\EMP> grails create-domain-class User ->this command is create a User Class .

u can Edit this grails-app/domain/User.groovy class , add attribute

class User{

String userName

String password

static constraints = {}

}

similarly create Controller for User.Class

c:\EMP> grails create-controller User

u can Edit this grails-app/controller/UserController.groovy class ,

class UserController {

def scaffold = User

}

now save this classes and run application

c:\EMP> grails run-app

hit http://localhost:8080/EMP on browser u will see the index page with user controller action link, u can now easily perform Add/Modify/Delete/List feature

Groovy

2009-06-25T22:28:00.000-07:00

* Scripting / Agile Dynamic Language for JVM

* Features inspired from Python, Ruby.

* Syntax very close to Java and Same OO model as Java

* Seamless integration with all existing Java classes and libraries.

* Groovy code Compiles to Java bytecode.

* Can run on .Net 2.0 using IKVM

* Latest version 1.6

* http://groovy.codehaus.org

Groovy Basic

1. Closures

2. Dynamic Methods

3. List & Maps

4. Better XML/Swing Capabilities

5. Permits operator Overloading

6. GString: interpolated String

1. Closure :

=> Closures are reusable blocks of code

=> One or more program statements enclosed in curly brackets “{}”

=> Closures do not require a class or a method name

=> Can be passed around like variables

=> The statements within a closure are not executed until the call() is made

=> Return is using an explicit return statement or the value of the last executed statement.

=> E.g. square = { it * it } //“it” implicit parameter representing the passed value.

square (4) // Output = 16

def name = "Gaju"

def printClosure = { println "Hello, ${name}" } //output : Hello, Gaju

//Passing Parameters to Closures

def printClosure = {name -> println "Hello, ${name}" }

printClosure("Gaju") //output : Hello, Gaju

def list = [‘hritbh’, ‘sagar’, ‘somkant’]

def sayHello = {println it}

list.each(sayHello)

Sample class & script:

class Speaker {

String name

def age

String toString() { "MY name is $name and I'm $age“ }

public static void main(String []args){

def speaker = new Speaker(name:'Gajanan Koram', age:27)

println speaker.toString()

def speakers = [new Speaker(name:'Rod Johnson', age:36),

new Speaker(name:'Guillaume Laforge', age:29)]

def upper = { it.toString().toUpperCase() }

speakers.findAll { name -> name =~ /.*od.*/ }.collect(upper).each { println it }

}

}

/*

Compile code : groovyc Speaker.groovy

run : groovy Speaker

output : MY name is Gajanan Koram and I'm 27

MY NAME IS ROD JOHNSON AND I'M 36

*/

2. Dynamic Methods:

=> Add new methods to an object at runtime

=> Intercept non-existent method calls :

• Tracing and debugging

• Mocks and stubs

=> Meta-Object Protocol : changes structure and behaviour at runtime

class webcamp{

def haveTea() {

println"Time for tea"

}

}

camp = new webcamp()

camp.haveTea()

Eg. Add a new method “haveSamosa”

camp = new webcamp()

camp.haveTea()

webcamp.metaClass.haveSamosa= { ->

println"Have Samosaalso"

}

camp = new webcamp()

// Create a fresh object since the class has changed!

camp.haveSamosa()

3. Lists and Maps:

=> Lists look like arrays but are of type java.util.List plus new methods.

[1,2,3] + [1] == [1,2,3,1]
[1,2,3] << 1 ="=">
[1,2,3,1] - [1] == [2,3]
[1,2,3] * 2 == [1,2,3,1,2,3]
[1,[2,3]].flatten() == [1,2,3]
[1,2,3].reverse() == [3,2,1]
[1,2,3].intersect([4,3,1]) == [3,1]
[1,2,3].collect{ it+3 } == [4,5,6]
[1,2,3,1].unique().size() == 3
[1,2,3,1].count(1) == 2
[1,2,3,4].min() == 1
[1,2,3,4].max() == 4
[1,2,3,4].sum() == 10
[4,2,1,3].sort() == [1,2,3,4]
[4,2,1,3].findAll{it%2 == 0} == [4,2]
=> Maps are like lists that have an arbitrary type of key instead of integer.
def map = [a:0, b:1]
Map iteration methods take the nature of Map.Entry objects into account.
map.each { key, value ->
println "$key $value"
}

4. Building XML

def writer = new StringWriter()
def bldr = new groovy.xml.MarkupBuilder(writer )
bldr.languages {

language(name: 'C++' ) { author('Stroustrup' )}
language(name: 'Java' ) { author('Gosling' )}
language(name: 'Lisp' ) { author('McCarthy' )}
}

println writer

Output :
Stroustrup
Gosling
McCarthy

5. Operator Overloading

=> Groovy uses operator overloading to create shortcuts that make Java friendlier.

For example, adding an object to a list in Java looks like this: myList.add(someObject).

The corresponding Groovy way of adding an object to a list is

myList <<>

=> Groovy operators and their corresponding methods.

Operator Method

a + b a.plus(b)

a - b a.minus(b)

a * b a.multiply(b)

a ** b a.power(b)

a / b a.div(b)

a % b a.mod(b)

a | b a.or(b)

a & b a.and(b)

a ^ b a.xor(b)

a++ or ++a a.next()

a-- or --a a.previous()

a[b] a.getAt(b)

a[b] = c a.putAt(b, c)

a << style=""> a.leftShift(b)

a >> b a.rightShift(b)

switch(a) { case(b) : } b.isCase(a)

~a a.bitwiseNegate()

-a a.negative()

+a a.positive()