java packages ant cvs project submission n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
CMSC 341 PowerPoint Presentation
Download Presentation
CMSC 341

Loading in 2 Seconds...

play fullscreen
1 / 26

CMSC 341 - PowerPoint PPT Presentation


  • 195 Views
  • Uploaded on

Java Packages Ant CVS Project Submission. CMSC 341. Packages. Java packages create libraries A group of classes organized together into a single namespace . Allows multiple classes with the same name MyPackage.Stack YourPackage.Stack. Packages. A file may belong to only one package.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'CMSC 341' - lynch


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
java packages ant cvs project submission
CMSC 341 CVS/Ant

Java Packages

Ant

CVS

Project Submission

CMSC 341
packages
CMSC 341 CVS/AntPackages
  • Java packages create libraries
    • A group of classes organized together into a single namespace.
    • Allows multiple classes with the same name
      • MyPackage.Stack
      • YourPackage.Stack
packages1
CMSC 341 CVS/AntPackages
  • A file may belong to only one package.
  • Packages serve as a namespace in Java and create a directory hierarchy when compiled.
  • Classes are placed in a package using the following syntax in the first line that is not a comment.
  • package packagename;
  • package packagename.subpackagename;
multiple stack classes
CMSC 341 CVS/AntMultiple Stack Classes
  • // My stack.java file
  • package MyPackage;
  • public class Stack
  • {
  • // …
  • };

// Your stack.java file

package YourPackage;

public class Stack

{

// …

};

packages cont
CMSC 341 CVS/AntPackages (cont.)
  • The fully qualified name of a class is the packageName.ClassName.
    • java.lang.String
    • MyPackage.Stack
    • YourPackage.Stack
  • To alleviate the burden of using the fully qualified name of a class, use an import statement before the class declaration.
      • import java.util.StringBuffer;
      • import java.util.*;
      • import MyPackage.Stack;
      • import YourPackage.*;
packages cont1
CMSC 341 CVS/Ant

Project1

Root of project directory tree

src

proj1

Package name

Example.java

bin

Package name

proj1

Example.class

Packages (cont.)
  • It is common practice to duplicate the package directory hierarchy in a directory named src and to compile to a directory named bin.
  • Create this directory manually in your GL account
    • Eclipse creates this directory structure for you
compiling with packages
CMSC 341 CVS/AntCompiling with packages
  • When using the Unix command line, classes in a package are compiled using the –d option.
  • Given the directory structure on the previous slide, run the command below from the src directory to compile the code from the Project1/src directory to the Project1/bin directory.
  • The -d switch tells the compiler where to place the .class file
  • The bin directory must exist before compiling. The compiler will create the proj1 directory under bin.

javac –d ../bin proj1/Example.java

packages and eclipse
CMSC 341 CVS/AntPackages and Eclipse
  • By default Eclipse automatically creates a src/ directory when you create a new Java Project
  • Eclipse will then automatically create a bin/ directory and associated package directory hierarchy when it compiles your Java classes
    • Note: the bin/ directory tree is hidden by Eclipse when in the Java perspective, but you can see it if viewing the file system.
what is ant
CMSC 341 CVS/AntWhat is Ant?

Ant is a Java based tool for automating the build process

Platform independent commands (works on Windows, Mac & Unix)

XML based format

Easily extendable using Java classes

Ant is an open source (free) Apache project

Ant files used in this course require the package directory structure described earlier

anatomy of a build file
CMSC 341 CVS/AntAnatomy of a Build File

Ant’s build files are written in XML

Convention is to call file build.xml

Each build file contains

A project

At least 1 target

Targets are composed of some number of tasks

Build files may also contain properties

Like macros in a make file

Comments are within <!-- --> blocks

projects
CMSC 341 CVS/AntProjects

The project tag is used to define the project to which the ANT file applies

Projects tags typically contain 3 attributes

name – a logical name for the project

default – the default target to execute

basedir – the base directory relative to which all operations are performed

Additionally, a description for the project can be specified from within the project tag

project tag
CMSC 341 CVS/AntProject tag

<project name="Sample Project" default="compile" basedir=".">

<description>

A sample build file for this project

Recall that “.” (dot) refers to the current directory

</description>

</project>

properties
CMSC 341 CVS/AntProperties

Build files may contain constants (known as properties) to assign a value to a variable which can then be used throughout the project

Makes maintaining large build files more manageable and easily changeable

Projects can have a set of properties

Property tags consist of a name/value pair

Use the property names throughout the build file

The value is substituted for the name when the build file is “executed”

build file with properties
CMSC 341 CVS/AntBuild File with Properties

<project name="Sample Project" default="compile" basedir=".">

<description>

A sample build file for this project

</description>

<!-- global properties (constants) for this build file -->

<property name="source.dir" location="src"/>

<property name="build.dir" location="bin"/>

<property name="doc.dir" location="doc"/>

</project>

tasks
CMSC 341 CVS/AntTasks

A task represents an action that needs execution

Tasks have a variable number of attributes which are task dependant

There are a number of built-in tasks, most of which are things which you would typically do as part of a build process

mkdir - create a directory

javac - compile java source code

java - execute a Java .class file

javadoc - run the javadoc tool over some files

And many, many others…

For a full list see: http://ant.apache.org/manual/tasksoverview.html

targets
CMSC 341 CVS/AntTargets

The target tag has the following required attribute

name – the logical name for a target

Targets may also have optional attributes such as

depends – a list of other target names for which this task is dependant upon, the specified task(s) get executed first

description – a description of what a target does

Targets in Ant can depend on some number of other targets

For example, we might have a target to create a jarfile, which first depends upon another target to compile the code

Targets contain a list of tasks to be executed

build file with targets
CMSC 341 CVS/AntBuild File with Targets

<project name="Sample Project" default="compile" basedir=".">

<!-- set up some directories used by this project -->

<target name="init" description="setup project directories">

<!-- list of tasks to be executed -->

</target>

<!-- Compile the java code in src dir into build dir -->

<target name="compile" depends="init" description="compile java sources">

<!-- list of tasks to be executed -->

</target>

<!-- Generate javadocs for current project into docs dir -->

<target name="doc" depends="init" description="generate documentation">

<!-- list of tasks to be executed -->

</target>

<!-- Execute main in the specified class under ${build.dir} -->

<target name=”run" depends=“compile” description=”run the application">

<!-- list of tasks to be executed -->

</target>

<!-- Delete the build & doc directories and Emacs backup (*~) files -->

<target name="clean" description="tidy up the workspace">

<!-- list of tasks to be executed -->

</target>

</project>

initialization target tasks
CMSC 341 CVS/AntInitialization Target & Tasks

Our initialization target creates the build and documentation directories

The mkdir task creates a directory

<project name="Sample Project" default="compile" basedir=".">

...

<!-- set up some directories used by this project -->

<target name="init" description="setup project directories">

<mkdir dir="${build.dir}"/>

<mkdir dir="${doc.dir}"/>

</target>

...

</project>

compilation target tasks
CMSC 341 CVS/AntCompilation Target & Tasks

Our compilation target will compile all java files in the source directory

The javac task compiles sources into classes

Note the dependence on the init task

<project name="Sample Project" default="compile" basedir=".">

...

<!-- Compile the java code in ${src.dir} into ${build.dir} -->

<target name="compile" depends="init" description="compile java sources">

<javac srcdir="${source.dir}" destdir="${build.dir}"/>

</target>

...

</project>

slide20

Run Target & Tasks

  • Our run target will execute main in the fully specified class
    • Typically dependent on the compile task

<project name="Sample Project" default="compile" basedir=".">

...

<!-- Execute main in the fully qualified name under ${build.dir} -->

<target name=”run" depends=”compile" description=“run the application">

<java directory=“${build.dir}” classname=“${main.class}” fork=“yes”>

<arg line=“${args}” />

</java>

</target>

...

</project>

July 2011

20

CMSC 341 CVS/Ant

running ant command line
CMSC 341 CVS/AntRunning Ant – Command Line

Move into the directory which contains the build.xml file

Type ant followed by the name of a target

unix> ant run

unix> ant compile

Type ant at the unix prompt to run the project’s default target -- see screen shot on next page

unix> ant

project submission
CMSC 341 CVS/AntProject Submission
  • Projects in this course will be submitted electronically through the use of an industry standard version control system named CVS.
  • CVS can be used from the Unix command line, or from an Eclipse perspective.
  • In either case, we must be familiar with Java packages and their associated directory structure as discussed earlier.
what is cvs
CMSC 341 CVS/AntWhat is CVS?

Concurrent Versioning System (CVS) is one of the earlier SCM systems which gained wide adoption

Open source

Easy to install and use

Simple command line client

Wide integration in a lot of development tools

Used for submitting projects in this course

For good introduction on version control and CVS see the following book…

Pragmatic Version Control using CVS

cvs terminology
CMSC 341 CVS/AntCVS Terminology

Repository – the place where resources (files) are stored

Checkout – copy resources from the repository and create a working copy

Checkin/Commit – place resources from your working copy into the repository

Add – place a resource under version control

Remove – delete a resource from version control

Update – pull down changes from the repository into your working copy

using cvs in this course
CMSC 341 CVS/AntUsing CVS in this course
  • See http://www.cs.umbc.edu/courses/undergraduate/341/fall12/projects/CVS.html
  • For additional slides about CVS submission via Eclipse:
  • http://www.cs.umbc.edu/courses/undergraduate/341/Lectures/CVS/intro-to-cvs.ppt