2024. március 28., csütörtök

Gyorskeresés

Saját blog, brainstorming

Írta: |

[ ÚJ BEJEGYZÉS ]

Szeretnék csinálni magamnak egy tudás-megosztó blogot. Ez azt jelenti, hogy az elmúlt években, na jó inkább csak évben, vagy még inkább fél évben összegyűlt pár how-to, amit eddig egy privát wordpress blogban tároltam, de nem vagyok kibékülve a CMS-ekkel, így szeretnék magamnak csinálni -gyakorlás képpen- egy blogot. Designoláshoz nem értek, így vélhetően nagyon minimál lesz, de a cél, hogy reszponzív legyen, mobilról is jól lehessen böngészni majd.

3 fő része lenne a blognak, szerver oldal, adatbázis, és kliens oldal. Most azon ötletelek, hogy milyen technológiákat használjak. Jelenleg így képzelem el:

Adatbázis réteg: mongoDB
Szerver-oldal: nodejs rest szervizekkel
Kliens oldal: Dart, angular, twitter/bootstrap

Valahogy úgy kéne megcsinálni, hogy közben a kódot verziózom. Ami eddig megvan:

- szervergép: egy RPI rajta debian. egy svn repo a fájloknak, nodejs telepítve.
- kliens gép: ez csak azért kell, mert a szervergép nem grafikus, csak cli van, így pl a szerver oldali Dart fejlesztés nehézkes lenne. Tehát az alkalmazást egy kliens gépen fogom fejleszteni, de futni majd egy szerveren fog, a kódmegosztást subversion-nel tervezem.

Folyt. köv.

Szerk. 1 2014.04.04

Első állomásként megcsináltam az adatbázist, a szerveroldal vázát, és pár rest függvényt, így már el lehet kezdeni foglalkozni a frontend-el.

Adatbázis: MongoDB, Ubuntu-n vagyok itt fent volt a repoban, így az installálás csak egy
sudo apt-get update
sudp apt-get install mongodb

Ha fent van, akkor konzolban mongo parancs-al tudjuk előcsalogatni az adatbázis cli felületét. Ha valaki már használta mysql -nél a konzolos felületet annak ez sem lesz idegen. Ide most csak azért lépünk be hogy létrehozzuk a blogunk adatbázisául szolgáló database-t, illetve a userek, és article-ök tábláit.
MongoDB-ben nincs create database, vagy create table parancs, helyette:
use myblogdb
Ezzel létrejött a myblogdb adatbázis és rögtön használni is tudjuk. A use myblogdb parancs analóg a mysql-es paranccsal, annyi a különbség, hogy mysql-ben előtte létre kellett hozni az adatbázist.

Tehát a myblogdb adatbázisban vagyunk, de még nincsenek tábláink (megj: mongodb-ben a táblákat collection-öknek, a sorokat documents-nek, az oszlopokat fieldeknek nevezik).
Tábla létrehozásnál sem kell create utasítás, egy collection(~table) akkor jön létre ha adatot töltünk bele. A példa után világosabb lesz:
db.users.insert({ name: "PHUser"})
a db kulcsszó mindig arra az adatbázisra utal amiben éppen vagyunk, esetünkben myblogdb. a users a collection neve, az insert utasítás pedig magától értetődő, hogy mit csinál.

Megjegyzés: amikor majd a kódból kérdezzük le az adatbázist, akkorra már tudnunk kell, hogy milyen sémájú dokumentumok lesznek a users, és az articles collectionökben. Én a jelenlegi béta állapotban ilyen sémákat hoztam létre a collectionöknek:

users:

email : { type: String, default: '', index: {unique: true} },
password : { type: String, default: '' },
profile : {
nickname : { type: String, default: ''},
name : {
first : { type: String, default: ''},
last : { type: String, default: ''}
},
gender: { type: String, default: 'male'}
}

articles:

publish_date : { type: Date, default: new Date() },
author : { type: String, default: '' },
title : { type: String, default: 'This post has no title yet' },
labels : { type: [String], default: [] },
content : {},
comments : {}

Ezek persze még biztos változni fognak :(

Hol tartunk?
- fent van a MongoDB, van egy adatbázisunk, és két collectionünk, egy users és egy articles nevű.

Server: készítettem egy server.js nevű fájlt, ez szolgálja majd ki a beeső HTTP GET request-eket. Az elején megadtam a függőségeket:
var restify = require('restify');
var mongoose = require('mongoose');
var DBProvider = require('./database/dbprovider').DBProvider;
var UserProvider = require('./database/userprovider').UserProvider;
var ArticleProvider = require('./database/articleprovider').ArticleProvider;

A restify a REST szerver miatt kell (npm install restify), a mongoose pedig, itt idézek "elegant mongodb object modeling for node.js" (npm install mongoose) segítségével egyszerűbb lesz nodejs-ből menedzselni az adatbázist. A 3 *Provider pedig saját magam által írt javascript kód (~modul).

Az applikáció könyvtár struktúrája jelenleg ilyen:
.
├── client
└── server
├── database
│   ├── articleprovider.js
│   ├── dbprovider.js
│   └── userprovider.js
├── node_modules
│   ├── mongodb
│   ├── mongoose
│   └── restify
├── server.js

Így már talán érthetőbb. A DBProvider modul az adatbázishoz való kapcsolódásért felel. Álljon itt egy példa a DBProvider modulból:

DBProvider.prototype.connect = function() {
this.client.connect(this.database);
var db = this.client.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
console.log("Database Client connected");
});
}

a this.client példányosításkor a mongoose objektumot fogja megkapni. Ezen a mongoose objektumon keresztül tudunk kapcsolódni az adatbázishoz, mint ahogy a fenti példán is látszik.

server.js:
var dbProvider = new DBProvider('mongodb://127.0.0.1:27017/woowie', mongoose);
dbProvider.connect();

A másik kettő pedig értelem szerűen a felhasználók, és bejegyzések olvasásáért/mentésért az adatbázisba.

server.get('/getusers', findAll);
server.get('/user/:email', findUserByEmail);
server.get('/new/user', addUser);
server.get('/new/article', newArticle);

Jelenleg ezek az elérhető szolgáltatások, ezek már elegendőek ahhoz, hogy elkezdhessen építeni a frontendet.

Itt is álljon egy rövidebb példa, hogy hogyan tudunk lekérdezni az adatbázisból (megj: ne felejtsük el, hogy már meghívtuk a DBProvider connect metódusát, így az adatbázishoz való kapcsolódásról már nem kell gondoskodnunk)

UserProvider.prototype.findUserByEmail = function(req, res, next) {
var email = req.params.email;
var promise = this.model.findOne({"email": email}).exec();
promise.addBack(function(err, user) {
if(err) {
console.error(err);
}
res.send(user);
});
}

DART

A kliens oldalt a Dart programnyelvvel fogom elkészíteni. Álljon itt most pár gondolat azoknak akik nem ismernék a Dart-ot.

A Dart programozási nyelv open source, 2011-ben hozták létre a Google-nél azzal a céllal, hogy egy hatékonyabb eszközük legyen a webes platformra annál, mint amivel most rendelkeznek. A nyelv elemeit több nyelvből ollózták össze, nem fogom mind felsorolni, számunkra ami érdekes az a java, és a javascript.
A Java-val az a kapcsolat, hogy osztoznak elég sok kulcsszóban, lehet Dartban úgy programozni, hogy az majdhogynem összetéveszhető egy Java kóddal, de ez csak a szintaktika, amúgy nem sok köze van a két nyelvnek egymáshoz. A Dart rendelkezik egy VM-mel -> Dart VM, ami nem bytecode VM mint a JVM, hanem source kódot dolgoz fel. Ez számunkra csak azért érdekes, mert a Dart VM-el feldolgozott Dart kód sokkal gyorsabb mint a V8-as JS, kár, hogy a Dart VM jelenleg csak a Dartiumban elérhető.

A Dartium a Chrome/Chromium egy portolt változata amiben benne van a Dart VM. Amikor letöltjük a Dart-ot akkor nem csak az SDK-t kapjuk meg, hanem a Dart Editort is, ami egy Eclipse alapú editor kódkiegészítéssel, statikus típus analízissel stb... Egész jól használható editor. Illetve kapunk egy Dartiumot is, így Development phase-ben gyorsan tudjuk debugolni az alkalmazást, mint ahogy azt megszoktunk a webes platformon.

Kanyarodjunk vissza a nyelvhez. Alpból dinamikusan típusos nyelvről beszélünk, de van lehetőségünk statikus tipusokat is használni, ez utóbbinak a fejlesztés során van nagy szerepe, amikor az alkalmazásunk futni fog, akkor már nem lesznek jelen a tipusok. A dart kódot a Dartium tudja futtatni, de mivel szó szerint senki nem használ Dartiumot otthon, így nyílván ezzel nem vagyunk kisegítve, de az SDK-val kapunk egy dart2js toolt is, ami a Dartban írt kódunból csinál javascriptet. Azok dolgoznak a Dart-on akik a V8-at is írták, így a generált js kódra nem lehet panaszunk.

Miért választottam Én a Dartot?

Mert új, és ki akarom próbálni. Mert sok olyan hasznos dolog van benne, amit fentebb nem írtam le, mégis az alkalmazás elkészítése során nagyon hasznosnak fognak bizonyulni, párat nézzünk meg csak felsorolásképp:

- Pub package manager, a függőségek (pl jquery, angular, stb) kezelése sokkal egyszerűbb
- statikus típusok: a programozói hibák még compile time kiderülnek, kifejezőerő
- class-based inheritance, ez meg olyan mint amihez a Java-ban hozzászoktunk
- Future objektumok nyelvi szinten ~= js promises
- import, library, part of kulcsszavak, sokkal egyszerűbb a saját kód management. ~= Require.js csak nyelvi szinten
stb...

Folyt. köv.

Hozzászólások

(#1) Jim-Y


Jim-Y
veterán

open

(#2) lezso6


lezso6
HÁZIGAZDA
LOGOUT blog

Subversiont konkrétan a fájlok feltöltésére is használnád? Mert erre inkább egy Samba szervert ajánlanék, nekem nagyon bevált, és messze gyorsabb egy (S)FTP-nél. No meg a használat is egyszerűbb, hogy bármilyen stock windows-on meghajtóként csatlakoztathatod az elérni kívánt linuxos mappát. Verziókövetésre pedig GIT, messze rugalmasabb, mint egy ósdi SVN.

Mongóval meg óvatosan, nagyon jó (főleg nodejs-hez), de csak addig amíg csak egyszerű adatszerkezetekről van szó. Ha valami összetett cuccot akarsz kreálni, onnantól nem lehet megúszni egy SQL adatbázist.

A RIOS rendkívül felhasználóbarát, csak megválogatja a barátait.

(#3) Jim-Y válasza lezso6 (#2) üzenetére


Jim-Y
veterán

Köszi az otleteket. Holnap atragom magam rajtuk. Eloszor egy baromi egyszeru koncepciot szeretnek megvalositani ket tablaval~collectionnel. Az egyik a usereknek. uname passwd email role, a masik a bejegyzeseknek hasonloan egyszeru lenne az is. Ma este odaig jutottam el hogy megy a mongo, letrehoztam a users tablat feltoltottem egy admin adattal es ezt kiszolgalom nodejs-el. Holnap folyt kov.

(#4) Jim-Y


Jim-Y
veterán

szerkesztve 2014.04.04

További hozzászólások megtekintése...
Copyright © 2000-2024 PROHARDVER Informatikai Kft.