Vous êtes sur la page 1sur 48

Getting Started with Angular 2

By Juned Laliwala

AboutthisAngular2eBook.

BasicUnderstandingofAngular2.
UnderstandingModules,ComponentsandTemplates.
UnderstandingtheConceptsofTypeScripts.
BasicWebPagesusingAngular2.

Contents
1.

Preface

1.1

About this Guide

1.2

Intended Audience

1.3

Revision History

2.

Introduction to Angular 2

2.1

What is Angular 2?

2.2

Advantages of using Angular 2

3. Installation of Angular 2

3.1

Basic Environment Setup

3.2

Creating First Angular Component

4.

Creating First Simple Example

5.

Basic Architecture of Angular 2

6.

Modules, Components and Templates

6.1 Creating A Module

6.2 Creating a Component and Templates

6.3 Two-way Data Binding

7.

Concept of Multiple Component

8.

Creating a Service

9.

Routing Concept in Angular 2

Adding Routing

Making a Home-Page

Adding Navigation to the templates

10.

Saving Employees Details

Adding new Employee

Deleting Employee

11.

Working with HTTP Concept

Summary

1. Preface
1.1

About this Guide

This guide is for the developers or the users who wants to have the basic
understanding of the new JavaScripts that are coming into the market.
Angular2isoneofthem.Angular2istheadvancedconceptof AngularJs.In
this guide,you willcomeacrossmanyaspectsoftheAngularApplicationlike
making modules, templates and components for the particular application.
We willbeshowingmanydemonstrations alongwiththedesiredcodesothat
thereaderwillgetthebenefitsforthiseBook.

1.2

Intended Audience

Thisguideis purely intended forthe usersorthe developerswhohaveakeen


interestinthescriptingside.Thedeveloperswhohavebasicunderstandingof
the AngularJs will be finding quite interesting concepts as they have gone
through the scripting languages. For the learners whohavejustenteredinto
the scripting side willnotbe a troublesomefor themaswehaveexplainedin
thisebookallthebasicunderstandingofAngular2

1.3

Revision History

ThisbookisinreferencewiththeAngularJs. Theusersorthedeveloperswho
havepreviewedthebasicconceptsofAngularJswill findagoodknowledgeof
the Angular 2 Application. By looking at the AngularJs concept we have
startedmakingthisbooksfortheAngular2.

2. Introduction to Angular 2

2.1

What is Angular 2?

Angular 2, which is the enhanced version of AngularJs. As we all are aware about that
AngularJs is one of the best JavaScript framework forbuildingvariousWebandMobile
Applications. Similarly, with Angular 2 we are going to do the same work by adding
some more good functionality to the project, but this additional functionality is very
simpletocreateandasaresultwecanveryperfectoutput.

2.2

Advantages of using Angular 2

HighPerformanceApplicationswillbedeliveredwiththehelpofAngular2.
WecancreatemanyDesktopandMobilebasedApplications.
Speed for developing application increased as compared to other scripting
languages.
Testing,CodingandAnimationcanalsobeaccessedveryeffectively.

3. Installation of Angular 2

3.1Basic Environment Setup


First of all, wehavetounderstandthebasicmeaningofthetypescriptbefore movingforward
to the realworld application. The word TypeScript which is the main and the primary
language for developing any angularjs Application. Angular 2 is mainly concerned with the
word typescript, so we will make the whole application with the help of typescript.
Rememberonethingthattheextensionofthetypescriptfilesis.ts.
Create a Project Folder using terminal by giving the following command. mkdir
Attune_angular2 and cd Attune_Angular2 or you can also make a folder by your own
choice. This foldershouldbekeptinanyofyourdesiredlocation.Insidetheprojectfolder,in
order to install Angular 2inyour applicationsomemandatoryfilesneedtobeincludedtothe
projectfolder.
Tsconfig.json
Typings.json
Package.json
A configuration file is one of the base part of the application which can run on the platform
on which the file is being developed. So now as usual we will have to create one
configurationfileforthetypescriptformakingourapplicationcomfortablewithtypescript.

Fig:tsconfig.json

Similarly,nowwewillcreatetypings.jsonfile

Thedefinitionofthetypescriptingisusuallyincludedintotypings.jsonfileneededforour
angularjsApplication.
From the above figure we can seethattherearethreetypings filesthathavebeenincludedso
letusdiscussabouttheminmoredetailedway:
corejs: Its main use is to bring the ES201516/ES6 Capabilities to our platform
dependentbrowsers.
jasmine:Itsnothingbutthetypingjasmineframework.
node:Forprovidingnode.jsenvironmenttoourapplication.
The main Part of the Angular JavaScript total depends upon the installed packages
dependencies. So if there are not anysingledependencywithinourapplicationthenthereare
verymuchlargeamountoferrorthatcanbeencountered.
After that we have to give the command npm install toinstallallthedependenciesthatwe
haveusedorencountered.

3.2

Creating First Angular Component

After successfully installing all the dependencies the main part of the Angular 2 starts.
Component, which is the core part of Angular is being created by making a new subfolder
inside our project root folder. So now all our component related functionalities will be
handlesinsidethenewlycreatedsubfolder.(Inourcaseappsubfolder).
The files thathavebeencreatedforthetypescriptingwillbesavedin.ts extension.Nowlet
uscreateanewtypescripttomakebetterunderstandingofthefiles.

Fig:SimpleAppComponent
From the above figure we can see the basic typescripting inside our appfolder.Thenameof
the file is app.component.ts. We will see the better understanding of the below created ts
file.

ComponentandViewwillbeimportedfromtheangular2/core
@componentwillallowustoassociatemetadatawiththecomponentclass.
MyappcanbeusedasanHTMLtag.
@viewwillcontaintheViewingpartoftheapplication.
Export is the part which is solely responsible for the components that are outsidethe
files.

Nowwewillmovenextstepfurthertocreateanewfilenamedmain.ts

NowtheIndex.htmlfilewillbe:

Fig:Index.html
Rememberthatcurrentlywearedisplayingthesimplewebpagesothisisjustthebasichtml
file.Insidethishtmlfileweareimportingtheapp.

Fig:OutputofaSimpleDemo
From the above figure we can see that we have imported the above statement inside the
<myapp> tag which is nothing but the selector field in the Component part. So whatever
contentthathasbeendisplayedontomyapptagwillbedisplayedontothescreen.
Advanced concept of Components will be covered in the coming sections. So this was just
the overview about the installation and simple demonstration has been included in this
section about how to start with the Angular 2 and its corresponding environment. Now we
will cometothepracticalsessioninwhichwewillimplementsometasksothatwecaneasily
understandtheadvancedconcept.

4. Creating First Simple Example

Nowwearegoingtodemonstrateyoua simpleandstraightforwardexamplewhichwillclear
all your understanding about the Angular 2 Application. Simply we will have to create two
important file one file whichwillhandletheviewpartandanotherwillbethecomponentfile
for the created part. The former file will be the main file whereas the second will be the
component.tsfilewhichisillustratedintheabovediagram.

Fig:hello_attune_main.ts
This file is the file which will handle the classofthecomponentfile.Thebootstraphasbeen
used to import the view part of the currently exported file that we will show in the next
diagram.

Fig:hello_attune_app.component.ts
The above diagram is the component file of the hello_attune file. In the first line of this file
we can see that we are importing Component and View from the core of the angular
application. As we know that selector is nothing but the html tag which we arepreferring to
be used by the component. So in our case the selector myattune will be handling the
template which is beingincluded intoViewpartofthefile.Atlastweareexportingtheclass,
this exported classisnothingbutitwillbeusedbythemainfilethatwehavediscussedinthe
preciousarticle.
SothiswasjustthesimplewaytostartwithourAngular2Application.

5. Basic Architecture of Angular 2

Fig:Angular2Architecture
From the above diagram we can see that theoverallarchitectureisbeingdividedintomainly
8differentparts.
1.
2.
3.
4.
5.
6.
7.
8.

Module
Component
Template
Metadata
DataBinding
Service
Directives
DependencyInjection

Module as also reviewed in Angularjs that the mainroleofthemoduletoperformthesingle


task that we usually use during the blockofcode.ApartfromtheAngularjswehavean extra
functionality of exporting the class usingexportmethodinAngular2.Applicationswhichare
being made in Angular2 are basically Modules and as such byusingasmuchasmoduleswe
cancreateAngular2App.

In our Angular2 Application we will find AppComponent in many cases which is nothing
butthecomponentclassandwillbecontainedinsideapp.component.tsfile.
export class AppComponent { } is the statement which is used to export the components
that we have created in the modules. The meaning of the export in the statement is that it is
specifying the module and this AppComponent is public or we can say viewable for all the
othermodulesintheapplication.

Component is mainly associated with the view of the application and the logics that weare
applying to our application. The main role of componentclassintheoverallapplicationisto
check the dependency injection and based on that it can render its content itself.
@Component is the statement to identify that it is acomponentanditsmainusetobreakthe
application into separate different parts to identify a particular task. One thing that everyone
shouldrememberthatwecanuseonlyoneDOMelementperComponentClass.

Template part of theAngular2isnothingbuttheviewthattheuserwantstoseeisdisplayed


in this section. We just have to import the basic HTML syntax that we want to view the
templates.

Metadataisinsimplewordsmeansthat dataof data.InourAngularConceptwecansaythat


theclassthattheoverallprocessingofthefunctionisbeinghandledbythemetadata.Suppose
we have made one simple component and thiscomponentwillremaintheclassonlyuntilwe
clearly define this class as a component. We are referring to the term named Decorator to
attachthetypescripttoaMetadataandthisisdenotedby@Component.
@Component({
selector:myemployees,
template:<h2>EmployeeDetails</h2>,
directives:[myEmployees]
})
exportclassEmployeeComponent{..}

@Component is a directive which usually contains three basic parameters. From the above
example we can see that we have created one selector named myemployees. Selector will
basically create the instance of the component wherever it finds <myemployees> tag in the
parent HTML. The template as we know it will simple display the templates or the view of

the page. Directives is used to representthearrayofthecomponentsor thedirectivesthatwe


havespecifiedintheapplication.

Data Binding is the process by which we can collaborate with the application values by
declaring the bindings between source and target html elements. Template part is combined
with the component part using Data Binding. There are usually four types of Data Binding:
Interpolation,PropertyBinding,EventBindingandTwowayBinding.

Services are nothing but the functions that we have implemented in our applications can be
easily identified using the services. Its main purpose is to identify or perform some specific
tasks only. Various services are available for logging, registration, user service, data service
andsoon.ServicesarethefundamentalcoretoAngularApplications.
Directive is solely responsible for Metadata representation in our Angular Applications.
Component Directives, Decorator Directives and Template Directives are the three types of
DirectivesinAngular.

Dependency Injection is nothing but the Object Passing as dependencies in different


components of the application. New creation of the class alongwithitsdependencieswillbe
createdusingDependencyInjection.

6. Modules, Components and Templates

6.1 Creating A Module


A module can be created as many as module in a single application. In the typical sense we
can say that a module is a group of code which is integrated with othermodulesforrunning
theparticularapplications.

Fig:CreatingaSimpleModule
From the above figure we can see that we are importing AngularModuleNgModulefrom
core elements of Angular. Apart from it we are also importing Browser Module which is
solelyresponsibleforhandlingBrowserSpecifictasks.
@NgModuleisthefunctionthroughwhichwecanimport,declareandidentifythebootstrap
whicharebeingusedfortheparticularproject.

6.2 Creating a Component and Templates


ComponentisthemainpartoftheAngular2applications.Fromthefiguregivenbelow,we
canseethat@ComponentstatementisusedtoinvokeaComponentpart.Insidethiswehave
includedtwomainparts(JustforthisExample)Selectorandtemplate.Selectorpartas
wehavealsodiscussedintheprevioussectionthatitwillhandletheHTMLsyntaxof
<myapp>part.Intemplatespart,wewillhavetodefinewhateverHTMLcodewewantto
rendertodisplaytheViewingofthewebpages.
Infiguregivenbelow,wecanseethatwearepassingsimpletextinthetemplatesection.

Fig:CreationofComponentandTemplate
As we can see in thelastlineofthefigure,exportclassAppComponent,themainroleisto
add some more parameters into it and to call this parameter to use in our angular 2
Application. From the figure shown below, we can see that we are passing two parameters
namelynameanddesignationtodisplayonouroutput.

Fig:ComponentwithParameters
Fromtheabovefigurewecanseethatwehavepassedtwovaluesintoournameand
designationparametersandin@Componentfunctionwearedefiningthosevaluesusing
angulardirectives.Sothedesiredoutputis:

Fig:OutputofSimpleComponent&Template.
AsfaraswehaveseenthebasicimplementationoftheAngular2.Nowwewillfocuson
creatingtextboxforinputtingthevalues

Fig:TextboxinApplication

Thiswasthesimpleexampletoillustratetheuseoftextbox.

6.3 Two-way Data Binding


AsweallareawareaboutthedatabindingthatwehavebeingdoinginAngularjsbyputting
ngmodelininputtag.Thesamecaseishereweareputtingthesamengmodelinadifferent
syntaxas[(ngmodel)].SoletusseethebasicfunctionalityoftheTwowayDataBinding.
ForTwowayDataBindingcomesintoaction,wehavetokeepFormsModuleinour
moduletypescriptconfigurationfile.

Fig:Componentwithngmodel

Fig:Outputwithngmodel

Tillnowwehaveseentheentryofonlysingleelement.NowwewillpasstheEmployeelist
asanarray.SowiththehelpofarraywewillstaticallyinserttheNameandDesignationof
Employees.

StepsforCreatingArray:
1. Firstofall,exporttheclassofEmployee.

2. AddthestaticvaluestotheNameandDesignationoftheEmployees.
3. ListtheElements.
Thisthreestepswillbenowshownwiththedemonstration.

Fig:DefiningNameandDesignationbyExportingClass
From the above figure we can see that we have included empl_name and
empl_designation to denote the nameanddesignationoftheemployees.ThisClassusually
means that inside the Employee there are two main parameters namely their name and
designation.NowwewillinsertthestaticvaluesintotheEmployeeClass.

Fig:StaticValuespassedintoArray
From the above figure we can say that we have inserted total five Employees list. The most
important part in listing in angular 2 is to define a constant value for the Employee List. In
the first line of the Array list we have defined one statement const EMPLOYEES:
Employee[ ] which means that we are using the constant word EMPLOYEES for the
currently exported class named Employee. So all the values of the name and designation
partwillnowbehandledbyEMPLOYEES.

Fig:ComponentandAppComponentExportedclass
Now our main task is to display the Name of all the Employees along with theDesignation.
So in @Component part we can see that in the list partweare using*ngForfordenotingthe
acceptable parameter values that are eligible for the list. As we can see in the
AppComponent Class, we are referring our Array list asemployees,soallthestaticvalues
ofthelistwillbenowhandledbyemployeesparameter.
Employees = Employees is the main statement that is mandatory to be applied in order to
passthevaluesintothelist.
Sothedesiredoutputwillbe:

From the abovefigure,wecan seethatanautomaticgeneratedlisthasbeendevelopedforthe


staticvaluesthathasbeenpassedintothelist.

7. Concept of Multiple Component

So far we have seen the basic use of only single component in ourapplication.Nowwewill
move one step further and introduce the concept of adding more than one component in a
single file. In the previous section we have seen that we have made the list of Employee
Name and their respective designation. Now we will make one separate component for the
EmployeeDetailswhichwillhandletheoveralldetailsoftheemployees.
For this to take intoeffect,wewillcreateanewfileinsideourappfolderand wewillnameit
asemployeedetail.component.ts.

Fig:EmployeeDetailComponentTypeScript
So now we are ready with a separate typescript file which includes selector as
myemployeedetail. The main issue that we should remember is to identify the component
andthefileswhichcontainsthatComponents. Intheabovefigurewecanseethatnameofthe
file is employeedetail.component.ts and the name of the class is
EmployeeDetailComponent. Sothisconfusionshouldnowbeclearintheoverallaspectsof
Angular2Applications.
Component names will always end with Component whereas filename will always end
with.component.
So,nowalltheEmployeeDetailswillbestoredinemployeedetail.component.tsfile.

Fig:employeedetail.component.ts
From the figure shown above we can see that all the values that were defined inside the
AppComponent will now be clearly handled by the separate typescript file for Employee
Details. Nowtheconflictoccursaswehavedeclaredthe Employeeinapp.componentfilebut
we are preferring to this newly created typescript file. No issue, we will now create a new
employee.tsfile
We have exported Employee Class in both the files, so we will have to import the
employee.ts file in both the component files namely app.component.ts and
employeedetail.component.ts by giving the statement as import { Employee } from
./employees.

Fig:employee.ts
Sointheabovefigurewehavesimplymadeanewtypescriptfilefortheemployees.
Similarly, after modifications that we have discussed, we have imported anewlycreatedfile
of Employee. Apart from it we have also exported the EmployeeDetailComponent which is
handlingtheuserinputsfromtheEmployees.

Fig:ComponentFileofEmployee

8. Creating a Service

The main roleoftheserviceintheAngular2isthatabasicfunctionsortheparameterwillbe


called in one simple file andthevaluesthathavebeendefinedinto thisservicewillbeshared
byallthefilesthatwanttofunctionwiththatparticularfile.
Step1:Createatypescriptfileinwhichwewillhavetodefinetheparametersthatarebeing
usedforthedata.

So in the above diagram we can see that we have made one Employee class which is
containingID,NameandAddressoftheparticularemployee.
Nowwewillgivesomestaticvaluestotheparametersthatwehavedefinedforit.

Fig:AddingStaticValuestoEmployeesField
Aswecanseefromtheabovediagramthatwehavegivensomestaticvaluestoit.
Nowwewilldefineaservicewiththehelpoftheabovetwofiles.

In ourcase,wehavecreatedEmployeelisttoshowtheirnamesandtheir designation.Nowto
show proper demonstration of the service we will make one service on Employees and will
include more parameters into it. These parameters will be viewed or shared by all other
componentsthatwantstouseEmployeeclass.
Here we are going to create a service for Employees by making a new file named
employee.service.ts.

Fig:ServiceforEmployee
From theabovefigurewecan seethatwehaveimportedInjectablefunctionandinthenext
line we have also applied this as a function using @Injectable().It is recommended to put
@Injectable() anyhow whether it is in use or not. Now inside the EmployeeService class
we have injected one function named getEmployees to list the employee related service
files. Whatever the service functioniswillnowallbehandledbythisEmployeeServiceonly.
When the results are ready to be declared then with the help of Promise we will get the
desired output whenever the Output is available. Promise usually works in Asynchronous
way.

Fig:app.component.ts
In the first three lines of the above diagram we can easily see that we have imported the
methodswhichwehavecalledforthedifferentpurpose.
OnInitisnothingbuttheinitializationoftheangularapplication.
@Componentpartisalreadydiscussedintheprevioussection.
In the Appcomponent exported class, we can see that we have defined one constructor for
calling our services. This service we have declared it as a public. After that we are calling
getemployees() function, in which we can see thatwearecalling all theparametersthathave
been definedlikeid,nameandaddress.InthelastwehaveinitializethemethodwithOnInit()
torecallourmethods.
Sothedesiredoutputwillbe:

Fig:OutputofEmployeeList

From the above figure we can see that thelistthatwehaveincludedintoouremployeelistis


now available as output. So the complete list of all the employees are being displayed onto
thescreen.

9. Routing Concept in Angular 2

Till now we haveseenthatthe simplelistoftheemployeeswasdisplayedontotheoutput


of the application with the help of the service. In this content, we will make someof the
pages and we will redirect from one page to another. In our case, we have made list of
employees so will make one page whichwill havetheemployeesnameandinthesecond
pagewewillredirecttheadditionaldetailsoftheemployees.
Step1:SplittingtheAppComponent
Till now in the previous section, we have seen that the App was simply showing the list
of all the employees that we were putting statically. Now we will make different pages
anddisplaydifferentcontenttothedifferentpages.
In this step, we have to simple rename the three important files namely app.component
file,AppComponentparameterandmyappselectortoanyofourdesiredname.
So as for example we are changing the value of app.component file to
employees.component.ts, AppComponent to EmployeesComponent and myapp selector
tomyemployees.
The main reason forchangingtheapp.componentfileisthatthisfilebenowworkingasa
shell. This file will now be containing linksfordifferentpagesthatneedstobenavigated
fromonepagetoanother.

Fig:employees.component.ts
As we have discussed that we have to change the file name to better understand the
concept of the routing. We havesimplymadethechangesthatwerebeingencounteredin
theprecioussection.

Fig:NewlyCreatedapp.componentFile
From the above figure we can see that a new app componentfilehas beencreatedwitha
selector as myapp. Butaswecanseethatthereissomechangeinthetemplatesection,
we have included <myemployees> tag. This tagisnothingbuttheemployeeslistwillbe
called in the output that we have done in the previous sections. The reason for declaring

<myemployees> as a tag is that in the previous figure we can see that the selector has
beenmyemployeessowearepreferringthistag.
After configuring this changes, we will now have to add someparameterstoourModule
file for our application. We first simply have to include theComponentfileofEmployee
Listbyimportingthemfromthelocationwhereitisavailable.

Fig:app.module.ts(Afterchanges)
Fromtheabovefigurewecanseethatwehaveimportedthefilesandthecorresponding
outputwillbe:

Fig:DesiredOutput

So thisresultissameasthepreviousone.Soeverything tillnowitsperfect.Nowwewill
add some routing functionalities in such a way that when the user clicks on any of the
employees list, then the complete details of the Employees will be displayed on thenext
page.

Adding Routing
Now we are moving further by clicking on a single employee, we will be able to seethe
complete details of them on the next page. This process is also called the navigation of
thepages.
The main functionalities of the Routing will be handled by RouterModule. Thisrouteris
particularly a combination of multiple provided services (RouterModule), multiple
directives (RouterOutlet, RouterLink, RouterLinkActivate) and Configuration(Routes).
This threefilesare themostimportantpartforunderstandingtheroutingfunctionalitiesin
Angular.
Step1:Basetag
Inindex.htmlfile,belowtheheadsectionandatthetopitismandatorytoptopdefineone
basetagas:<basehref=/>
Step2:ConfigureRoutes
Currentlywearenothavingasimplerouteinourapplication.Sofirstwewillcreateone
configurationfileforroutingandletssaywenameitasapp.routing.tsinsidetheapp
folder.Themainaimofroutesisthatittellstheroutertolinktowhichpagewhenthe
userclicksonthebutton.

Fig:app.routing.ts

The Routes that you are seeing in the above definition basically contains an array of the
route definition. Currently thereisonly singleroutedefinition,butintherealtimewecan
useasmanyasrequiredfortheapplication.
Now this routes contains basic two parts: Path is nothing but thelink orthepaththatwe
have provided will be checked by the router in the browser. Component is the
componentnamethattherouterwantstoconfigurethepath.
ThisroutesistobeaddedtotheModulefileinsidetheNgModule.

Fig:app.module.ts
<Routeroutlet>:isnothingbutthedirectivewhichisprovidedbytheRouterModule.
Themainroleofrouteroutletisthattherouterwilldisplayeachandeverycomponent
immediatelybelowrouteroutlet

Fig:RouterLinkExample
ThemainroleofrouterLinkistoprovidethelocationwheretonavigate.

Making a Home-Page
Nowwewillmakeonehomepagesuchthatwhenevertheuserstartstheapplicationthen
theuserwillbefirstredirectedtothispage.

Fig:MainPageComponentFile
1. Wehavemadeafilenamedmainpage.component.tswhichisnothingbutthe
componentfileforthemainpage.
2. Selectorforthispageismymainpage.WhereasExportedclassnameis
MainPageComponent.

Nowtoaddroutingfunctionality,wewillhavetogobacktoapp.routing.tsandaddthe
followingroutepathasshowninthebelowdiagram.

Fig:ApplyingRoutesusingappRoutes

AswecanseethattherearenowtwoComponents,sowehavetoalsoincludethat
Componentsintomodulefileas:

Fig:IncludingEmployeesandMainPageinDeclaration

redirectToisasthenamesuggestsisusedtomovetothelocationthathasbeenappliedto
move.Inthefigureshownbelowitisbeingredirectedtothemainpage.Thismainpageis
notconsideringpathasblankwhichmeansitisthedefaultpage.

Fig:RedirectToinrouting.ts

Adding Navigation to the templates


Herewearemakinganewpagenamedmainpagewhichisnothingbutthehomepagethat
willbeopenwheneverwestartourapplication.

Fig:MainPageComponentFile

Soaswecanseethatwehaveincludedasimpletitleintoourmainpagecomponentsothat
wecanjustcheckwhethertheapplicationshowsthemainpageornot.

Fig:OutcomeoftheMainPage

Thebelowfigureshowsthatthelinkthatcanbeprovidedfortheapplication.Fromthefigure
wecanseethatwehaveincludedtwolinksintoourproject.

Fig:EmployeesListPagewithMenuLinks

Now with the help of routing we will click on any of our Employees and we will see the
complete detailsofthatparticularEmployeesinanotherpage.Forperformingsuchatask,we
willhavetoinvokesomemethodsthatwewillseeinthefollowingsection.

Fig:Employeedetails.Component.ts

This is theEmployeeDetailspage.Wewilldiscussthecompletedetailsofthispage.Firstwe
can see that we have importedActivatedRouterandParamswhicharemandatoryforrouting
which usuallycomesthecorepartoftheAngularApplications.Incomponentpart wearenow
defining the path of html file by passing the path of the file. The route file that we have
imported in the header part needs to be defined inside the exported Component class. We
have as usual imported the Initialization oftheangularbypassingtheIDoftheemployeesin
the Employees service and with the help of such parameters we can see thecompletedetails
oftheEmployee.

Fig:getEmployee()Method

Now, inside the service file of the employee we are making a new function namely
getEmployee which is getting the parameter as ID and based on this ID the

complete details of the Employees will be called by the getEmployees( ) function as


wecanseethefunctionalitiesthatwehavedefinedinsidethisservice.

So far we have seen that we have to get the completedetailsoftheemployeessothatweare


defining one of the function inside a button so that when the user clicks on the button, the
completedetailswillbedisplayedontothenextscreen.

Fig:gotoDetailFunction
GotoDetailisthefunctiontogetthecompletedetailsbasedonEmployeesID.

As we can see from the above figure that we have applied a button click and inside
that click we have called one function named gotoDetail which is nothing but the
detailsoftheemployeeswillbedisplayedontothescreen.

Fig:OutcomeoftheEmployeePage

Now as we can see that when the user clicks on one of the Employee then name is
being displayed ontosamepage.Now whentheuserclicksontheviewdetailsbutton
thenthedetailsofthepagewillbeas:

Fig:EmployeeDetailsonthenextPage

So cool, we have the details of the Employee and in the browser we can see the url
part,itisdisplayingtheIDofthedisplayedEmployee.

10. Working with HTTP Concept

So far as we have seen in the AngularJs that the modules that we were referring for
using HTTO was HttpModule. The same is the case withtheAngular2,herealsowe
are using HttpModule. The main intense is to access the web pages and it exists on
anothercorepartofangular2thatis@angular/http.
Now as we are going to use HTTP Modules into our application, so we have to
mandatorilyimporthttpmodulesintoourappsmodulesfile.

Currently we are not having any web service for handling the data that we are going
to access using http modules. So we will make one temporary web service for
showingthedemonstrationofthewebservicesusinghttprequests.

So again we will have to import two important things for Http Modules namely
InMemoryWebApiModule andInMemoryDataServiceinmodulefile.Apartfrom
it we will have to import in NgModule the important field as shown in the figure
below:

Fig:
FromtheabovefigurewecanseethatwehaveimportedInMemoryWebApiModule,
thismodulereplacestheHttpClientBackendwiththeInMemoryDataService.Soall
thehttpwebclientwillbenowhandledbyInMemoryDataService.
The main use of forroot inwebApiModuleisthatwillhandlethe databaseservice
asshowninthediagrambelow:

Fig:MakingDatabasefile
From the above figure we can see that we have imported Database Service and after
that we are exporting the class of the Data Service. InsidethisDataServiceclass,we
aremakingoneDatabasenamedemployeesandaddingsomestaticvaluesintoit.

In the file that we have made named mockemployees.ts which were handling all
the details about the employees so now its safe to delete that file because now we
have made one database file in which we will handle the employees Complete
details.

Fig:OldGetEmployeesServiceFile

FromtheabovefigurewecanseethatwehavemadeonegetEmployees()servicefile
inwhichweweregettingthecompletedetailsoftheemployeesbyreturningthe
Promiseparametertofetchthedetails.Nowthetimehascometoreplacethispromise
byputtingthedatabasefileinregardstoPromisetofetchthedetails.
ThechangesthatarebeingmadetoServicefileoftheEmployeesisasfollows:

Fig:ChangesinServiceFiles

So after refreshing the browser, we can see that overall functionalities remains the
same.Sothatmeansweareontherightpath.
In the previous service file we were using the promise parameter to fetch thedetails,
but now we are preferring the rxjs Observable parameter to work the same details.
Instead of the using Promise method wearenowusing.toPromise()function.After
that we are calling the parameters by using response.json data, which will return all
thedetailsoftheemployeesintoourapplication.

Saving Employees Details

As we have seen so far that we were adding the employees details and were able to
view the employees but nowwhenweedittheemployeesthenwecaneasilysave that
employees details on to the next page. We will make a button to save the details.
Whentheuserclicksonthesavebuttonthenthedetailswillbeupdated.

In employeedetail.component html file , we are adding one button and inside that
button we are passing the save function to save the details of the employees. Now
inside the employeedetail component ts file we will add the save functionalities as
shownbelow:

Fig:SavetheEmployeeDetails

Now we have to applythe UpdateMethod thatwehavepassedintheabovefigure.In


Employeeservice.tsfilewehavetoupdateasfollows:

Fig:UpdateFunctioninEmployeeServiceFile

Aswecanseefromtheabovefigurethatwehaveupdatedtheemployeedetailsfor
theparticularEmployee.Sowhentheuserclicksonthesavebuttonthenupdated
detailswillbesavedontothemainpageas:

Fig:ChangingtheEmployeeDetails

Fig:CorrespondingOutputofEmployee

Adding new Employee


Nowinthiscontent,wearegoingtoaddthenewEmployeesintoourApplication.So
forthatwewillmakeoneAddbuttonintoourhtmlfile.InsidethatAddbuttonwe
willpassoneAddEmployeeFunctionwhichwilladdtheEmployeedetailstothe
Server.

Fig:AddingEmployee

Fig:CreatingEmployeeMethod

Fig:AddingEmployee

Fig:AddedEmployee

Deleting Employee

NowwewilldeleteaparticularEmployeefromthelist.

AddaButtontodeleteEmployee.

Applydeletefunction.

Fig:DeleteEmployeeinComponentFile

Fig:ServiceFile
SofarwehaveseenthebasicuseofHTTPinAngular2Application.Similarly,wecanmake
anydesiredapplicationoranyofthefunctionalitiesthatwecanworkwith.

11.

Summary

This was thebasicconcept oftheAngular2Application.Withthehelpofthistutorialwecan


get thebasicideaabouttheusageoftheModules,TemplatesandComponents.Inthistutorial
we have almost seen many examples with which we can work with. Angular 2 is the very
simple and easy to code technology. We also understood that with the help of typescript we
can generate javascript files automatically. So this was just the basic concept of theAngular
2. In the next section, we will come back with more extra functionalities of the Angular 2
Applications.ThankYou.