Go Lang + Angular + Mysql CRUD example - Go Full stack development

Hello everyone, today we will learn how to develop a full-stack web application that is a basic User Management Application using Angular, Go, and Mysql.GitHub repository link is provided at the end of this tutorial. You can download the source code.


After completing this tutorial what we will build?

We will build a full-stack web application that is a basic User Management Application with CRUD features: 

• Create User
• List All Users 
• Update User 
• Delete User 
• View User 


We divided this tutorial into two parts 

PART 1 - Rest APIs Development using Go and Mysql 

PART 2 - UI development using Angular


PART 1 - Rest APIs Development using Go Language

These are APIs that the Go Language application will export:

GET all User's        :     /users 
GET User by ID     :     /users/{_id} 
POST User             :     /users 
PUT User               :     /users/{_id} 
DELETE User       :     /users/{_id}

Backend Project Structure:


Create database 'userdb':

CREATE DATABASE userdb;

Create table 'users':

CREATE TABLE `users` (
`id` bigint(20) UNSIGNED NOT NULL,
`first_name` varchar(200) NOT NULL,
`last_name` varchar(200) NOT NULL,
`email` varchar(200) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;


ALTER TABLE `users`
ADD PRIMARY KEY (`id`),
ADD UNIQUE KEY `id` (`id`);

ALTER TABLE `users`
MODIFY `id` bigint(20) UNSIGNED NOT NULL
AUTO_INCREMENT, AUTO_INCREMENT=11;

Initialize the Go project:

Initialize the Go project using the following command
go mod init backend

Adding the modules required for the project:

go get github.com/gorilla/mux
go get github.com/go-sql-driver/mysql

main.go

package main

import (
"database/sql"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"

_ "github.com/go-sql-driver/mysql"
"github.com/gorilla/mux"
)

func main() {
Routers()
}

func Routers() {
InitDB()
defer db.Close()
router := mux.NewRouter()
router.HandleFunc("/users",
GetUsers).Methods("GET")
router.HandleFunc("/users",
CreateUser).Methods("POST")
router.HandleFunc("/users/{id}",
GetUser).Methods("GET")
router.HandleFunc("/users/{id}",
UpdateUser).Methods("PUT")
router.HandleFunc("/users/{id}",
DeleteUser).Methods("DELETE")
http.ListenAndServe(":9080",
&CORSRouterDecorator{router})
}

/***************************************************/

//Get all users
func GetUsers(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var users []User
result, err := db.Query("SELECT id, first_name," +
"last_name,email from users")
if err != nil {
panic(err.Error())
}
defer result.Close()
for result.Next() {
var user User
err := result.Scan(&user.ID, &user.FirstName,
&user.LastName, &user.Email)
if err != nil {
panic(err.Error())
}
users = append(users, user)
}
json.NewEncoder(w).Encode(users)
}

//Create user
func CreateUser(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
stmt, err := db.Prepare("INSERT INTO users(first_name," +
"last_name,email) VALUES(?,?,?)")
if err != nil {
panic(err.Error())
}
body, err := ioutil.ReadAll(r.Body)
if err != nil {
panic(err.Error())
}
keyVal := make(map[string]string)
json.Unmarshal(body, &keyVal)
first_name := keyVal["firstName"]
last_name := keyVal["lastName"]
email := keyVal["email"]
_, err = stmt.Exec(first_name, last_name, email)
if err != nil {
panic(err.Error())
}
fmt.Fprintf(w, "New user was created")
}

//Get user by ID
func GetUser(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
params := mux.Vars(r)
result, err := db.Query("SELECT id, first_name,"+
"last_name,email from users WHERE id = ?", params["id"])
if err != nil {
panic(err.Error())
}
defer result.Close()
var user User
for result.Next() {
err := result.Scan(&user.ID, &user.FirstName,
&user.LastName, &user.Email)
if err != nil {
panic(err.Error())
}
}
json.NewEncoder(w).Encode(user)
}

//Update user
func UpdateUser(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
params := mux.Vars(r)
stmt, err := db.Prepare("UPDATE users SET first_name = ?," +
"last_name= ?, email=? WHERE id = ?")
if err != nil {
panic(err.Error())
}
body, err := ioutil.ReadAll(r.Body)
if err != nil {
panic(err.Error())
}
keyVal := make(map[string]string)
json.Unmarshal(body, &keyVal)
first_name := keyVal["firstName"]
last_name := keyVal["lastName"]
email := keyVal["email"]
_, err = stmt.Exec(first_name, last_name, email,
params["id"])
if err != nil {
panic(err.Error())
}
fmt.Fprintf(w, "User with ID = %s was updated",
params["id"])
}

//Delete User
func DeleteUser(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
params := mux.Vars(r)
stmt, err := db.Prepare("DELETE FROM users WHERE id = ?")
if err != nil {
panic(err.Error())
}
_, err = stmt.Exec(params["id"])
if err != nil {
panic(err.Error())
}
fmt.Fprintf(w, "User with ID = %s was deleted",
params["id"])
}

/***************************************************/

type User struct {
ID string `json:"id"`
FirstName string `json:"firstName"`
LastName string `json:"lastName"`
Email string `json:"email"`
}

//Db configuration
var db *sql.DB
var err error

func InitDB() {
db, err = sql.Open("mysql",
"root:@tcp(127.0.0.1:3306)/userdb")
if err != nil {
panic(err.Error())
}
}

/***************************************************/

// CORSRouterDecorator applies CORS headers to a mux.Router
type CORSRouterDecorator struct {
R *mux.Router
}

func (c *CORSRouterDecorator) ServeHTTP(rw http.ResponseWriter,
req *http.Request) {
if origin := req.Header.Get("Origin"); origin != "" {
rw.Header().Set("Access-Control-Allow-Origin", origin)
rw.Header().Set("Access-Control-Allow-Methods",
"POST, GET, OPTIONS, PUT, DELETE")
rw.Header().Set("Access-Control-Allow-Headers",
"Accept, Accept-Language,"+
" Content-Type, YourOwnHeader")
}
// Stop here if its Preflighted OPTIONS request
if req.Method == "OPTIONS" {
return
}

c.R.ServeHTTP(rw, req)
}

Run:

go run main.go



PART 2 - UI development using Angular

Front Project Structure:


package.json 

A package.json is a JSON file that subsists at the root of a Javascript/Node project. It holds metadata pertinent to the project and is utilized for managing the project's dependencies, scripts, version, and a whole lot more.
{
"name": "frontend",
"version": "0.0.0",
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build",
"test": "ng test",
"lint": "ng lint",
"e2e": "ng e2e"
},
"private": true,
"dependencies": {
"@angular/animations": "~10.1.2",
"@angular/common": "~10.1.2",
"@angular/compiler": "~10.1.2",
"@angular/core": "~10.1.2",
"@angular/forms": "~10.1.2",
"@angular/platform-browser": "~10.1.2",
"@angular/platform-browser-dynamic": "~10.1.2",
"@angular/router": "~10.1.2",
"bootstrap": "^4.5.3",
"jquery": "^3.5.1",
"rxjs": "~6.6.0",
"tslib": "^2.0.0",
"zone.js": "~0.10.2"
},
"devDependencies": {
"@angular-devkit/build-angular": "^0.1100.3",
"@angular/cli": "~10.1.2",
"@angular/compiler-cli": "~10.1.2",
"@types/jasmine": "~3.5.0",
"@types/jasminewd2": "~2.0.3",
"@types/node": "^12.11.1",
"codelyzer": "^6.0.0",
"jasmine-core": "~3.6.0",
"jasmine-spec-reporter": "~5.0.0",
"karma": "~5.0.0",
"karma-chrome-launcher": "~3.1.0",
"karma-coverage-istanbul-reporter": "~3.0.2",
"karma-jasmine": "~4.0.0",
"karma-jasmine-html-reporter": "^1.5.0",
"protractor": "~7.0.0",
"ts-node": "~8.3.0",
"tslint": "~6.1.0",
"typescript": "~4.0.2"
}
}

The User.ts file [User Model]

Path - src/app/user.ts
 
Before defining the UserListComponent, let’s define a User class for working with users. create a new file user.ts inside the src/app folder and add the following code to it -
export class User {
id: string;
firstName: string;
lastName: string;
email: string;
active: boolean;

}

Create User List Template and Component

User List Component

Let's create the UserListComponent component which will be used to display a list of users, create a new user, and delete a user. 

Path - src/app/user-list/user-list.component.ts
import { Observable } from "rxjs";
import { UserService } from "../user.service";
import { User } from "../user";
import { Component, OnInit } from "@angular/core";
import { Router } from '@angular/router';

@Component({
selector: "app-user-list",
templateUrl: "./user-list.component.html",
styleUrls: ["./user-list.component.css"]
})
export class UserListComponent implements OnInit {
users: Observable<User[]>;

constructor(private userService: UserService,
private router: Router) {}

ngOnInit() {
this.reloadData();
}

reloadData() {
this.users = this.userService.getUsersList();
}

deleteUser(id: string) {
this.userService.deleteUser(id)
.subscribe(
data => {
console.log(data);
this.reloadData();
},
error => console.log(error));
}
updateUser(id: string){
this.router.navigate(['update', id]);
}
userDetails(id: string){
this.router.navigate(['details', id]);
}
}

User List Template

Path - src/app/user-list/user-list.component.html 

Add user-list.component.html file with the following code to it -
<div class="panel panel-primary">
<div class="panel-heading">
<h2>User List</h2>
</div>
<div class="panel-body">
<table class="table table-striped">
<thead>
<tr>
<th>Firstname</th>
<th>Lastname</th>
<th>Email</th>
<th>Actions</th>
</tr>
</thead>
<tbody>
<tr *ngFor="let user of users | async">
<td>{{user.firstName}}</td>
<td>{{user.lastName}}</td>
<td>{{user.email}}</td>
<td>
<button (click)="updateUser(user.id)"
class="btn btn-warning"
style="margin-left: 10px">Update</button>
<button (click)="deleteUser(user.id)"
class="btn btn-danger"
style="margin-left: 10px">Delete</button>
<button (click)="userDetails(user.id)"
class="btn btn-info"
style="margin-left: 10px">Details</button>
</td>
</tr>
</tbody>
</table>
</div>
</div>

Create Add User Template and Component 

Add User Component 

Path - src/app/create-user/create-user.component.ts CreateUserComponent is used to create and handle new user form data. Add the following code to it -
import { UserService } from '../user.service';
import { User } from '../user';
import { Component, OnInit } from '@angular/core';
import { Router } from '@angular/router';

@Component({
selector: 'app-create-user',
templateUrl: './create-user.component.html',
styleUrls: ['./create-user.component.css']
})
export class CreateUserComponent implements OnInit {

user: User = new User();
submitted = false;

constructor(private userService: UserService,
private router: Router) { }

ngOnInit() {
}

newUser(): void {
this.submitted = false;
this.user = new User();
}

save() {
this.userService
.createUser(this.user).subscribe(data => {
console.log(data)
this.user = new User();
this.gotoList();
},
error => console.log(error));
}

onSubmit() {
this.submitted = true;
this.save();
}

gotoList() {
this.router.navigate(['/users']);
}
}

Create a User Template 

The create-user.component.html shows the add using HTML form. Add the following code to it - 

Path - src/app/create-user/create-user.component.html
<h3>Create User</h3>
<div [hidden]="submitted" style="width: 400px;">
<form (ngSubmit)="onSubmit()">
<div class="form-group">
<label for="name">First Name</label>
<input type="text" class="form-control"
id="firstName" required
[(ngModel)]="user.firstName" name="firstName">
</div>

<div class="form-group">
<label for="name">Last Name</label>
<input type="text" class="form-control"
id="lastName" required
[(ngModel)]="user.lastName" name="lastName">
</div>

<div class="form-group">
<label for="name">Email </label>
<input type="text" class="form-control"
id="email" required [(ngModel)]="user.email"
name="email">
</div>

<button type="submit"
class="btn btn-danger">Submit</button>
</form>
</div>

<div [hidden]="!submitted">
<h4>Successfully submitted!</h4>
</div>

Update User Template and Component 

Update User Component 

Path - src/app/update-user/update-user.component.ts 

UpdateUserComponent is used to update an existing user.
import { Component, OnInit } from '@angular/core';
import { User } from '../user';
import { ActivatedRoute, Router }
from '@angular/router';
import { UserService } from '../user.service';

@Component({
selector: 'app-update-user',
templateUrl: './update-user.component.html',
styleUrls: ['./update-user.component.css']
})
export class UpdateUserComponent implements OnInit {

id: string;
user: User;
updated = false;

constructor(private route: ActivatedRoute,
private router: Router,
private userService: UserService) { }

ngOnInit() {
this.user = new User();

this.id = this.route.snapshot.params['id'];
this.userService.getUser(this.id)
.subscribe(data => {
this.user = data;
}, error => console.log(error));
}

updateUser() {
this.userService.updateUser(this.id, this.user)
.subscribe(data => {
console.log(data);
this.user = new User();
this.gotoList();
}, error => console.log(error));
}

onSubmit() {
this.updateUser();
this.updated = true;
}

gotoList() {
this.router.navigate(['/users']);
}
}

Update User Template 

Path - src/app/update-user/update-user.component.html 

The update-user.component.html shows the updated user HTML form. Add the following code to this file -
<h3>Update User</h3>
<div style="width: 500px;">
<form (ngSubmit)="onSubmit()">
<div class="form-group">
<label for="name">First Name</label>
<input type="text" class="form-control"
id="firstName" required
[(ngModel)]="user.firstName" name="firstName">
</div>

<div class="form-group">
<label for="name">Last Name</label>
<input type="text" class="form-control"
id="lastName" required
[(ngModel)]="user.lastName" name="lastName">
</div>

<div class="form-group">
<label for="name">Email</label>
<input type="text" class="form-control"
id="email" required [(ngModel)]="user.email"
name="email">
</div>

<button type="submit" class="btn btn-success">
Submit</button>
</form>
</div>

<div [hidden]="!updated">
<h4>Successfully updated!</h4>
</div>

Create a View User Details Template and Component 

User Details Component 

Path - src/app/user-details/user-details.component.ts 

The UserDetailsComponent component is used to display a particular user detail. Add the following code to it -
import { User } from '../user';
import { Component, OnInit, Input }
from '@angular/core';
import { UserService } from '../user.service';
import { Router, ActivatedRoute }
from '@angular/router';

@Component({
selector: 'app-user-details',
templateUrl: './user-details.component.html',
styleUrls: ['./user-details.component.css']
})
export class UserDetailsComponent implements OnInit {

id: string;
user: User;

constructor(private route: ActivatedRoute,
private router: Router,
private userService: UserService) { }

ngOnInit() {
this.user = new User();

this.id = this.route.snapshot.params['id'];
console.log("gh"+this.id);
this.userService.getUser(this.id)
.subscribe(data => {
console.log(data)
this.user = data;
}, error => console.log(error));
}

list(){
this.router.navigate(['users']);
}
}

User Details Template 

Path - src/app/user-details/user-details.component.html 

The user-details.component.html displays a particular user detail. Add the following code to it
<h2>User Details</h2>

<hr/>
<div *ngIf="user">
<div>
<label><b>First Name: </b></label>
{{user.firstName}}
</div>
<div>
<label><b>Last Name: </b></label>
{{user.lastName}}
</div>
<div>
<label><b>Email: </b></label>
{{user.email}}
</div>
</div>

<br>
<br>
<button (click)="list()" class="btn btn-primary">
User List</button><br>

User Service 

Path - src/app/user.service.ts 

The UserService will be used to get the data from the backend by calling  APIs. Update the user.service.ts file inside src/app directory with the following code to it -
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable({
providedIn: 'root'
})
export class UserService {

private baseUrl = 'http://localhost:9080/users';

constructor(private http: HttpClient) { }

getUser(id: string): Observable<any> {
return this.http.get(`${this.baseUrl}/${id}`);
}

createUser(user: Object): Observable<Object> {
return this.http.post(`${this.baseUrl}`, user);
}

updateUser(id: string, value: any):
Observable<Object> {
return this.http.put(`${this.baseUrl}/${id}`,
value);
}

deleteUser(id: string): Observable<any> {
return this.http.delete(`${this.baseUrl}/${id}`,
{ responseType: 'text' });
}

getUsersList(): Observable<any> {
return this.http.get(`${this.baseUrl}`);
}
}

App Routing Module 

Path: /src/app/app.routing.module.ts 

Routing for the Angular app is configured as an array of Routes, each component is mapped to a path so the Angular Router knows which component to display based on the URL in the browser address bar.
import { UserDetailsComponent }
from './user-details/user-details.component';
import { CreateUserComponent }
from './create-user/create-user.component';
import { NgModule } from '@angular/core';
import { Routes, RouterModule }
from '@angular/router';
import {UserListComponent }
from './user-list/user-list.component';
import { UpdateUserComponent }
from './update-user/update-user.component';

const routes: Routes = [
{ path: '', redirectTo: 'user', pathMatch: 'full' },
{ path: 'users', component: UserListComponent },
{ path: 'add', component: CreateUserComponent },
{ path: 'update/:id', component: UpdateUserComponent },
{ path: 'details/:id', component: UserDetailsComponent },
];

@NgModule({
imports: [RouterModule.forRoot(routes)],
exports: [RouterModule]
})
export class AppRoutingModule { }

App Component 

Path: /src/app/app.component.ts 

The app component is the root component of the application, it defines the root tag of the app as with the selector property of the @Component decorator.
import { Component } from '@angular/core';

@Component({
selector: 'app-root',
templateUrl: './app.component.html',
styleUrls: ['./app.component.css']
})
export class AppComponent {
title = 'Go Lang + Angular + Mongo DB CRUD ';
}

App Component Template 

Path: /src/app/app.component.html 

Defines the HTML template associated with the root AppComponent.
<nav class="navbar navbar-expand-sm
bg-success navbar-dark">
<!-- Links -->
<ul class="navbar-nav">
<li class="nav-item">
<a routerLink="users" class="nav-link"
routerLinkActive="active">User List</a>
</li>
<li class="nav-item">
<a routerLink="add" class="nav-link"
routerLinkActive="active">Add User</a>
</li>
</ul>
</nav>
<div class="container">
<br>
<h2 style="text-align: center;">{{title}}</h2>
<hr>
<div class="card">
<div class="card-body">
<router-outlet></router-outlet>
</div>
</div>
</div>

<footer class="footer">
<div class="container">
<span>All Rights Reserved
2022 @Knowledge Factory</span>
</div>
</footer>

App Module 

Path: /src/app/app.module.ts 

Defines the root module, named AppModule, that tells Angular how to assemble the application. Initially declares only the AppComponent.
import { BrowserModule }
from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { AppRoutingModule }
from './app-routing.module';
import { AppComponent } from './app.component';
import { CreateUserComponent }
from './create-user/create-user.component';
import { UserDetailsComponent }
from './user-details/user-details.component';
import { UserListComponent }
from './user-list/user-list.component';
import { UpdateUserComponent }
from './update-user/update-user.component';
import { HttpClientModule }
from '@angular/common/http';
@NgModule({
declarations: [
AppComponent,
CreateUserComponent,
UserDetailsComponent,
UserListComponent,
UpdateUserComponent
],
imports: [
BrowserModule,
AppRoutingModule,
FormsModule,
HttpClientModule
],
providers: [],
bootstrap: [AppComponent]
})
export class AppModule { }

index.html 

Path: /src/index.html 

The main index.html file is the initial page loaded by the browser that kicks everything off.
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>AngularGoCRUD</title>
<base href="/">
<meta name="viewport"
content="width=device-width, initial-scale=1">
<link rel="icon" type="image/x-icon"
href="favicon.ico">
</head>
<body>
<app-root></app-root>
</body>
</html>

Main/Bootstrap File 

Path: /src/main.ts 

The main file is the entry point used by angular to launch and bootstrap the application.
import { enableProdMode } from '@angular/core';
import { platformBrowserDynamic }
from '@angular/platform-browser-dynamic';

import { AppModule } from './app/app.module';
import { environment }
from './environments/environment';

if (environment.production) {
enableProdMode();
}

platformBrowserDynamic().bootstrapModule(AppModule)
.catch(err => console.error(err));

Frontend local setup

Step 1: The npm install installs all modules that are listed on package.json file and their
dependencies
npm install
Step 2: Run the Frontend application
ng serve
Hit http://localhost:4200 link in a browser that will host this Angular CRUD app.


Popular posts from this blog

Learn Java 8 streams with an example - print odd/even numbers from Array and List

Spring boot video streaming example-HTML5

Spring Boot + Mockito simple application with 100% code coverage

Spring Boot + OpenCSV Export Data to CSV Example

Custom Exception Handling in Quarkus REST API

Registration and Login with Spring Boot + Spring Security + Thymeleaf

DataTable-Pagination example with Spring boot, jQuery and ajax

Spring Webflux File Download - REST API Example

Node JS mini projects with source code - free download

ReactJS, Spring Boot JWT Authentication Example