vlambda博客
学习文章列表

// Use String for file reference. 
File wsdl = file('src/wsdl/sample.wsdl') 
 
// Use File object for file reference. 
File xmlFile = new File('xml/input/sample.xml') 
def inputXml = project.file(xmlFile) 

import java.util.concurrent.Callable 
 
// Use URL instance to locate file. 
def url = new URL('file:/README') 
File readme = file(url) 
 
// Or a URI instance. 
def uri = new URI('file:/README') 
def readmeFile = file(uri) 
 
// Use a closure to determine the 
// file or directory name. 
def fileNames = ['src', 'web', 'config'] 
def configDir = file { 
    fileNames.find { fileName -> 
        fileName.startsWith('config') 
    } 
} 
 
// Use Callable interface. 
def source = file(new Callable<String>() { 
    String call() { 
        'src' 
    } 
}) 

def dir = project.file(new File('config'),    PathValidation.DIRECTORY) 

$ gradle -q
FAILURE: Build failed with an exception.
* Where:
Build file '/Users/mrhaki/Projects/gradle-effective-implementation-guide-2/Code_Files/build.gradle' line: 1
* What went wrong:
A problem occurred evaluating root project 'files'.
> Directory '/Users/mrhaki/Projects/gradle-effective-implementation-guide-2/Code_Files/files/config' does not exist.
* Try:
Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.

// Check file or directory exists. 
def readme = project.file('README', PathValidation.EXISTS) 
 
// Check File object is really a file. 
def license = project.file('License.txt', PathValidation.FILE) 

// Use String instances. 
def multiple = 
    files('README', 'licence.txt') 
 
// Use File objects. 
def userFiles = 
    files(new File('README'), new File('INSTALL')) 
 
// We can combine different argument types. 
def combined = files('README', new File('INSTALL')) 

def urlFiles = 
    files(new URI('file:/README'), 
        new URL('file:/INSTALL')) 

// Use a Collection with file or directory names. 
def listOfFileNames = ['src', 'test'] 
def mainDirectories = files(listOfFileNames) 
 
// Use an array. 
// We use the Groovy as keyword to 
// force an object to a certain type. 
mainDirectories = files(listOfFileNames as String[]) 
 
// Or an implementation of the Iterable interface. 
mainDirectories = files(listOfFileNames as Iterable) 
 
// Combine arguments and pass another file collection. 
def allDirectories = files(['config'], mainDirectories) 

import java.util.concurrent.Callable 
 
def dirs = files { 
    [new File('src'), file('README')] 
    .findAll { file -> 
        file.directory 
    } 
} 
 
def rootFiles = files(new Callable<List<File>>() { 
 
    def files = [new File('src'), 
            file('README'), 
            file('INSTALL')] 
 
    List<File> call() { 
        files.findAll { fileObject -> 
            fileObject.file 
        } 
    } 
 
}) 

task convert { 
    def source = new File('source.xml') 
    def output = new File('output.txt') 
 
    // Define input file 
    inputs.file source 
 
    // Define output file 
    outputs.file output 
 
    doLast { 
        def xml = new XmlSlurper().parse(source) 
        output.withPrintWriter { writer -> 
            xml.person.each { person -> 
                writer.println "${person.name},${person.email}" 
            } 
        } 
        println "Converted ${source.name} to ${output.name}" 
    } 
} 
 
// Get the file collection from 
// the task outputs property. 
def taskOutputFiles = files(convert) 
 
// Alternatively we could use 
// the outputs property directly. 
taskOutputFiles = files(convert.outputs) 

// Define collection. 
def fileCollection = files('README', 'INSTALL') 
 
// Remove INSTALL file from collection. 
def readme = fileCollection - files('INSTALL') 
 
// Add new collection to existing collection. 
def moreFiles = 
    fileCollection + 
    files(file('config', 
            PathValidation.DIRECTORY)) 

task collectionPath << { 
    def fileCollection = files('README', 'INSTALL') 
    println fileCollection.asPath 
} 

$ gradle -q collectionPath
/Users/mrhaki/gradle-book/Code_Files/files/README:/Users/mrhaki/gradle-book/Code_Files/files/INSTALL

def fileCollection = files('README', [new File('INSTALL')]) 
 
// Get all elements as File objects. 
def allFiles = fileCollection.files 
 
// Or use casting with as keyword. 
def fileObjects = fileCollection as File[] 
 
 
def singleFileCollection = files('INSTALL') 
 
// Get single file as File object. 
def installFile = singleFileCollection.singleFile 

task filterFiles << { 
    def rootFiles = files('INSTALL', 'README') 
 
    // Filter for files with a txt extension. 
    def smallFiles = rootFiles.filter { file -> 
        file.name.endsWith 'txt' 
    } 
 
    rootFiles = rootFiles + files('LICENSE.txt') 
    // smallFiles now contains 2 files: 
    // INSTALL and LICENSE 
} 

// Create file tree with base directory 'src/main' 
// and only include files with extension .java 
def srcDir = fileTree('src/main').include('**/*.java') 
 
// Use map with arguments to create a file tree. 
def resources = 
    fileTree(dir: 'src/main', 
        excludes: ['**/*.java', '**/*.groovy']) 
 
// Create file tree with project directory as base 
// directory and use method include() on tree 
// object to include 2 files. 
def base = fileTree('.') 
base.include 'README', 'INSTALL' 
 
// Use closure to create file tree. 
def javaFiles = fileTree { 
    from 'src/main/java' 
    exclude '*.properties' 
} 

def sources = fileTree { 
    from 'src' 
} 
 
def javaFiles = sources.matching { 
    include '**/*.java' 
} 
 
def nonJavaFiles = sources.matching { 
    exclude '**/*.java' 
} 
 
def nonLanguageFiles = sources.matching { 
    exclude '**/*.scala', '**/*.groovy', '**/*.java' 
} 
 
def modifiedLastWeek = sources.matching { 
    lastWeek = new Date() - 7 
    include { file -> 
        file.lastModified > lastWeek.time 
    } 
} 

def testFiles = fileTree(dir: 'src/test') 
 
testFiles.visit { fileDetails -> 
    if (fileDetails.directory) { 
        println "Entering directory ${fileDetails.relativePath}" 
    } else { 
        println "File name: ${fileDetails.name}" 
    } 
} 
 
 
def projectFiles = fileTree(dir: 'src/test') 
 
projectFiles.visit(new FileVisitor() { 
    void visitDir(FileVisitDetails details) { 
        println "Directory: ${details.path}" 
    } 
 
    void visitFile(FileVisitDetails details) { 
        println "File: ${details.path}, size: ${details.size}" 
    } 
}) 

task simpleCopy(type: Copy) { 
    from 'src/xml' 
    into 'definitions' 
} 

// Define a closure with ANT-style 
// pattern for files. 
def getTextFiles = { 
    '**/*.txt' 
} 
 
task copyTask(type: Copy) { 
    // Copy from directory. 
    from 'src/webapp' 
 
    // Copy single file. 
    from 'README.txt' 
 
    // Include files with html extension. 
    include '**/*.html', '**/*.htm' 
 
    // Use closure to resolve files. 
    include getTextFiles 
 
    // Exclude file INSTALL.txt. 
    exclude 'INSTALL.txt' 
 
    // Copy into directory dist 
    // resolved via closure. 
    into { file('dist') } 
} 

task simpleCopy << { 
    // We use the project.copy() 
    // method in our task. We can 
    // leave out the project reference, 
    // because Gradle knows how to 
    // resolve it automatically. 
    copy { 
        from 'src/xml' 
        into 'definitions' 
    } 
} 

task archiveDist(type: Zip) { 
    from 'dist' 
 
    // Create output filename. 
    // Final filename is: 
    // dist-files-archive-1.0-sample.zip 
    baseName = 'dist-files' 
    appendix = 'archive' 
    extension = 'zip' 
    version = '1.0' 
    classifier = 'sample' 
} 

// By using task type Zip we instruct 
// Gradle to create an archive 
// in ZIP format. 
task archiveFiles(type: Zip) { 
    from 'dist' 
 
    // Copy files to a directory inside the archive. 
    into 'files' 
 
    // Set destination directory for ZIP file. 
    // $buildDir refers to default Gradle 
    // build directory 'build/'. 
    destinationDir = file("$buildDir/zips") 
 
    // Set complete filename at once. 
    archiveName = 'dist-files.zip' 
} 

task tarFiles(type: Tar) { 
    from 'dist' 
 
    // Set destination directory. 
    destinationDir = file("$buildDir/tarballs") 
 
    // Set filename properties. 
    baseName = 'dist-files' 
 
    // Default extension for tar files 
    // with gzip compression is tgz. 
    extension = 'tar.gz' 
 
    // Use gzip compression. 
    compression = Compression.GZIP // or Compression.BZIP2 
} 

// Define new property. 
ext.customProperty = 'custom' 
 
// Or we can use ext{} script block. 
ext { 
  anotherCustomProperty = 'custom' 
} 
 
task showProperties { 
    ext { 
        customProperty = 'override' 
    } 
    doLast { 
        // We can refer to the property 
        // in different ways: 
        println customProperty 
        println project.ext.customProperty 


        println project.customProperty 
    } 
} 

$ gradle showProperties
:showProperties
override
custom
custom
BUILD SUCCESSFUL
Total time: 1.469 secs

task showProperties { 
    doLast { 
        println "Version: $version" 
        println "Custom property: $customProperty" 
    } 
} 

$ gradle showProperties
:showProperties
Version: 4.0
Custom property: Property value from gradle.properties
BUILD SUCCESSFUL
Total time: 1.676 secs

task showProperties { 
    doLast { 
        println "Version: $version" 
        println "Custom property: $customProperty" 
    } 
} 

$ gradle -Pversion=1.1 -PcustomProperty=custom showProperties
:showProperties
Version: 1.1
Custom property: custom
BUILD SUCCESSFUL
Total time: 1.412 secs

task showProperties { 
    doLast { 
        println "Version: $version" 
        println "Custom property: $customProperty" 
    } 
} 

$ gradle -Dorg.gradle.project.version=2.0 -Dorg.gradle.project.customProperty=custom showProperties
:showProperties
Version: 2.0
Custom property: custom
BUILD SUCCESSFUL
Total time: 1.218 secs

task showProperties { 
    doLast { 
        println "Version: $version" 
        println "Custom property: $customProperty" 
    } 
} 

$ ORG_GRADLE_PROJECT_version=3.1 \
ORG_GRADLE_PROJECT_customProperty="Set by environment variable" \
gradle showProp
:showProperties
Version: 3.1
Custom property: Set by environment variable
BUILD SUCCESSFUL
Total time: 1.373 secs

println 'Simple logging message' 

$ gradle --debug
...
08:34:13.497 [QUIET] [system.out] Simple logging message
...

logging.captureStandardOutput LogLevel.INFO 
println 'This message is now logged with log level info instead of quiet' 
 
task redirectLogging { 
    doFirst { 
      // Use default redirect log level quiet. 
      println 'Start task redirectLogging' 
    } 
    doLast { 
      logging.captureStandardOutput LogLevel.INFO 


      println 'Finished task redirectLogging' 
    } 
} 

$ gradle redirectLogging
:redirectLogging
Start task redirectLogging
BUILD SUCCESSFUL
Total time: 1.448 secs

$ gradle --info redirectLogging
...
Start task redirectLogging
Finished task redirectLogging
...

$ gradle wrapper
:wrapper
BUILD SUCCESSFUL
Total time: 0.61 secs

$ gradle wrapper --gradle-version=2.12
:wrapper
BUILD SUCCESSFUL
Total time: 0.61 secs

task createWrapper(type: Wrapper) { 
    // Set Gradle version for wrapper files. 
    gradleVersion = '2.12' 
 
    // Rename shell scripts name to 
    // startGradle instead of default gradlew. 
    scriptFile = 'startGradle' 
 
    // Change location and name of JAR file 
    // with wrapper bootstrap code and 
    // accompanying properties files. 
    jarFile = "${projectDir}/gradle-bin/gradle-bootstrap.jar" 
} 

$ gradle createWrapper
:createWrapper
BUILD SUCCESSFUL
Total time: 0.605 secs
$ tree .
.
├── gradle-bin
│ ├── gradle-bootstrap.jar
│ └── gradle-bootstrap.properties
├── startGradle
├── startGradle.bat
└── build.gradle
2 directories, 5 files

task createWrapper(type: Wrapper) { 
    // Set URL with custom Gradle distribution. 
    distributionUrl = 'http://intranet/gradle/dist/gradle-custom-       2.12.zip' 
}