บทช่วยสอนเบื้องต้นสำหรับนักพัฒนา Java ที่รวมกับการเขียนโปรแกรม Node.js

ก่อนอื่น ฉันต้องยอมรับว่าในฐานะนักพัฒนา Java ที่มีประสบการณ์การพัฒนามากกว่าสิบปี ฉันได้สร้างกิจวัตรที่มีอยู่ตามธรรมชาติเพื่อแก้ไขปัญหาส่วนใหญ่ แม้ว่ามักจะดูยุ่งยากและยุ่งยากก็ตาม ตัวอย่างเช่น หากคุณต้องการอ่านไฟล์ คุณควรเริ่มต้นอินสแตนซ์ BufferedReader และส่งผ่านใน FileReader ซึ่งเกือบจะสมเหตุสมผล ฉันได้เขียนโค้ดดังกล่าวในหลาย ๆ โปรเจ็กต์ที่ฉันคิดว่าเป็น "ระดับองค์กร" และสนุกกับมันมาก มากจนอาจกล่าวได้ว่าผมเป็นเพียงคนคลั่งไคล้ภาษา Java ที่ดูหมิ่นภาษาอื่น

หากคุณกำลังอ่านโพสต์บนบล็อกนี้ คุณอาจตกอยู่ในความเข้าใจผิดที่ฉันพบเมื่อหลายปีก่อน ในฐานะนักพัฒนาที่มีคุณสมบัติเหมาะสม คุณควรเรียนรู้เทคโนโลยีใหม่ ๆ อย่างต่อเนื่องและเลือกเทคโนโลยีที่เหมาะสมตามความต้องการในการทำงานจริง แม้ว่าฉันจะอายุมากขึ้น และวันหนึ่งอาจจะเบื่อกับจาวาก็ตาม แต่ตอนนี้ฉันได้ค้นพบสิ่งใหม่ที่น่าตื่นเต้นจริงๆ node.js ก็เหมือนกับเด็กที่ได้ของเล่นแปลกใหม่มาให้ฉัน ในโพสต์บล็อกนี้ ฉันจะแสดงให้คุณเห็นถึงวิธีสร้าง Rest แบบง่ายๆ โดยใช้ Java EE Service เพื่ออ่านฐานข้อมูล MongoDB จากนั้นฉันจะใช้ node.js เพื่อให้ได้ฟังก์ชันการทำงานแบบเดียวกัน และคุณจะเข้าใจความตื่นเต้นของภาษาการพัฒนาใหม่นี้ได้ง่ายขึ้น

เริ่มต้นด้วยพื้นฐาน – Node.js คืออะไร?

ก่อนอื่น ฉันอยากจะชี้แจงให้ชัดเจนว่า Node.js ไม่ใช่ภาษาที่ "ทันสมัย" ที่มีเพียง "คนทันสมัย" เท่านั้นที่ใช้ แม้ว่าจะเริ่มต้นด้วยความเข้าใจนี้ แต่ฉันยินดีที่จะรายงานว่า Node.js เป็นภาษาสำหรับผู้ใหญ่ และในยุคอินเทอร์เน็ตปัจจุบัน Node.js ได้ค้นพบหนทางสู่องค์กรขนาดใหญ่บางแห่งแล้ว Node.js เป็นเครื่องมือที่มีประโยชน์มากในชุดทักษะของคุณและจะทำให้คุณประหลาดใจกับความง่ายในการสร้างโค้ดที่เสถียร ปลอดภัย และมีประสิทธิภาพ

กล่าวโดยย่อ Node คือภาษาสำหรับกิจกรรมฝั่งเซิร์ฟเวอร์ ใช้ภาษา Javascript และมีไลบรารีมากมายให้ใช้งาน เช่น โมเดล npm คุณสามารถเปรียบเทียบโมเดล npm เหล่านั้นกับแพ็คเกจ .jar ใน Java เมื่อคุณต้องการฟังก์ชันการทำงานและไม่อยากเขียนโค้ดทั้งหมดด้วยตัวเอง มีโอกาสที่ฟีเจอร์ที่คุณกำลังมองหาจะมีให้ในโมเดล npm แล้ว

โดยทั่วไปแอปพลิเคชันโหนดจะดำเนินการเพื่อเพิ่มประสิทธิภาพสูงสุดโดยใช้ประโยชน์จาก I/O ที่ไม่บล็อกและเหตุการณ์แบบอะซิงโครนัส สิ่งหนึ่งที่นักพัฒนา Java ต้องรู้คือแอปพลิเคชัน Node ทำงานในเธรดเดียว อย่างไรก็ตาม โค้ดโหนดแบ็กเอนด์ใช้หลายเธรดสำหรับการดำเนินการ เช่น การเข้าถึงเครือข่ายและไฟล์ ด้วยเหตุนี้ Node จึงเหมาะสำหรับแอปพลิเคชันที่ต้องการประสบการณ์แบบเรียลไทม์

ดำเนินการต่อ - รองรับ IDE

คุณอาจเป็นเหมือนฉันและ "มีชีวิต" และ "หายใจ" ใน IDE นี่อาจเป็นเพราะว่า Java ใช้คำมากเกินไปและต้องการให้เราเขียนโค้ดอย่างต่อเนื่องเพื่อทำหน้าที่ให้สมบูรณ์ในระหว่างกระบวนการพัฒนาซอฟต์แวร์ เมื่อเราค้นพบประโยชน์ของการเติมโค้ดให้สมบูรณ์ เราก็ค่อยๆ เรียนรู้ที่จะใช้ IDE ในการจัดการไฟล์ การดีบัก และฟีเจอร์ที่มีประโยชน์อื่นๆ พอจะพูดได้ว่าฉันชอบใช้ IDE และยังคงใช้มันต่อไปเมื่อทำงานกับ Nodeb ต่อไปนี้เป็น IDE ชุดแรกที่รองรับโหนดในปัจจุบัน:

1. Eclipse - ควรเริ่มต้นได้ง่ายหากคุณใช้งานใน Java อยู่แล้ว เพียงติดตั้งปลั๊กอิน Node.js
2.JetBrains IntelliJ IDEA - IDE เชิงพาณิชย์ยอดนิยม นี่คือ IDE ที่ฉันชื่นชอบจนถึงตอนนี้
3.Microsoft Visual Studio – ใช่ คุณอ่านถูกต้องแล้ว โหนดได้เติบโตขึ้นจนถึงจุดที่ Microsoft ได้เพิ่มการรองรับแบบเนทิฟใน Visual Studio การใช้งานนี้มีเสถียรภาพมากและ VS เป็น IDE ที่ฉันชื่นชอบเป็นอันดับสอง น่าแปลกที่ฉันใช้ VS สำหรับโครงการ Node พื้นฐานบางโครงการเท่านั้น
4.CodeEnvy - IDE บนเว็บ
5.Cloud9 - IDE บนเว็บ
6.SublimeText 2 - โปรแกรมแก้ไขข้อความที่ไม่ซับซ้อนซึ่งกำลังได้รับความนิยมในหมู่นักพัฒนามากขึ้นเรื่อย ๆ เนื่องจากมีลักษณะที่เบา

นี่คือ IDE บางส่วนที่ฉันชื่นชอบในการทำงานกับโปรเจ็กต์แบบโหนด แค่ตัวอย่างเท่านั้น

เริ่มต้นด้วยตัวอย่าง

ในส่วนที่เหลือของโพสต์บนบล็อกนี้ เราจะสร้างบริการ REST แบบธรรมดาโดยใช้ Java EE และ Node.js บริการ REST นี้จะอ่านข้อมูลจากฐานข้อมูล MongoDB และส่งคืนผลลัพธ์ไปยังผู้ร้องขอ การติดตั้งและการกำหนดค่าแอปพลิเคชันเซิร์ฟเวอร์ Java และฐานข้อมูล MongoDB อยู่นอกเหนือขอบเขตของบทความนี้

สร้างแอปพลิเคชัน Java ของเรา

ขั้นตอนที่ 1: กำหนดค่าไฟล์ pom.xml

ลองเรียกตัวอย่างนี้ว่า restexample และฉันจะใช้แอปพลิเคชันเซิร์ฟเวอร์ JBoss EAP สิ่งแรกที่เราต้องทำคือกำหนดค่าไฟล์ pom.xml สำหรับการจัดการการพึ่งพาโดยใช้ระบบ Maven build ต่อไปนี้เป็นไฟล์ pom.xml ที่มีการขึ้นต่อกันที่จำเป็นในแอปพลิเคชัน restexample ของเรา:

 <โครงการ xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation = "http:/ /maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>restexample</groupId> <artifactId>restexample</artifactId> <บรรจุภัณฑ์>สงคราม</packaging> <version>1.0</version> <name>restexample</name> <ที่เก็บข้อมูล> <พื้นที่เก็บข้อมูล> <id>eap</id> <url>http://maven.repository.redhat.com/techpreview/all</url> <releases> <enabled>true</enabled> </releases> <snapshots> <enabled>true</enabled> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>eap</ id> <url>http://maven.repository.redhat.com/techpreview/all</url> <เผยแพร่> <เปิดใช้งาน>จริง</เปิดใช้งาน> </releases> <snapshots> <enabled>true</enabled> </snapshots> </pluginRepository> </pluginRepositories> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <maven .compiler.source>1.6</maven.compiler.source> <maven.compiler.target>1.6</maven.compiler.target> </ คุณสมบัติ> <การพึ่งพา> <การพึ่งพา> <groupId>org.jboss.spec</groupId> <artifactId>jboss-javaee-6.0</artifactId> <version>3.0.2.Final-redhat-4</version> <type>pom</type> <scope>มีให้</scope> </dependency> <dependency> <groupId>org.mongodb</groupId> <artifactId>ไดรเวอร์ mongo-java</artifactId> <version>2.9.1</version> </dependency> </dependencies> </project>

เจ๋ง ค่อนข้างมีรายละเอียด แต่ฉันหวังว่าคุณจะเข้าใจโค้ดนี้ ในบล็อกโพสต์นี้ ฉันคิดว่าผู้อ่านรู้จัก Java อยู่แล้ว ดังนั้นฉันจะไม่อธิบายรายละเอียด

ขั้นตอนที่ 2: สร้างไฟล์ beans.xml และตั้งค่าการแมปเซิร์ฟเล็ตของเรา

ส่วนหนึ่งของตัวอย่าง เราจะใช้ CDI (Context Dependency Injection) ในคลาสการเข้าถึงฐานข้อมูลของเรา ตามคำแนะนำการกำหนดค่า CDI อย่างเป็นทางการ หากแอปพลิเคชันต้องการใช้ CDI จะต้องรวมไฟล์ bean.xml ไว้ในไดเร็กทอรี WEB-INF ของแอปพลิเคชัน เรามาสร้างไฟล์นี้และกำหนดค่าด้วยข้อมูลที่เราต้องการ ไปที่ไดเร็กทอรี /src/main/webapp/WEB-INF ของคุณและสร้างไฟล์ bean.xml และเพิ่มโค้ดต่อไปนี้:

 <?xml version="1.0"?><beans xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema- อินสแตนซ์" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://jboss.org/schema/cdi/beans_1_0.xsd"/>

นอกจากนี้เรายังต้องตั้งค่าการแมปเซิร์ฟเล็ตสำหรับ RESI API ของเราในไฟล์ web.xml เพิ่มอิลิเมนต์การแม็พเซิร์ฟเล็ตต่อไปนี้ให้กับไฟล์ในไดเร็กทอรี /src/main/webapp/WEB-INF:

 <servlet-mapping> <servlet-name>javax.ws.rs.core.Application</servlet-name> <url-pattern>/ws/*</url-pattern></servlet-mapping>

ขั้นตอนที่ 3: สร้างคลาส DBConnection

ณ จุดนี้ เราได้ตั้งค่าโปรเจ็กต์และไฟล์ pom.xml ของเรามีการขึ้นต่อกันของไดรเวอร์ของฐานข้อมูล MongoDB แล้ว อย่าลืมตรวจสอบให้แน่ใจว่าได้รวมไดรเวอร์ที่จำเป็นไว้ในแอปพลิเคชันของเราแล้ว สิ่งต่อไปที่เราต้องทำคือสร้างคลาสเพื่อจัดการการเชื่อมต่อฐานข้อมูล สร้างไฟล์ใหม่ชื่อ DBConnection.java วางไฟล์นี้ในไดเร็กทอรี /src/main/java/com/strongloop/data จากนั้นเพิ่มโค้ดต่อไปนี้ลงในไฟล์นี้:

หมายเหตุ: ตรวจสอบให้แน่ใจว่าการติดตั้งฐานข้อมูล MongoDB ของคุณได้รับการกำหนดค่าด้วยรายละเอียดการอนุญาตการเชื่อมต่อที่เหมาะสม!

 แพ็คเกจ com.strongloop.data; นำเข้า java.net.UnknownHostException; นำเข้า javax.annotation.PostConstruct; นำเข้า javax.enterprise.context.ApplicationScoped; นำเข้า javax.inject.DB; ; @Named@ApplicationScopedpublic คลาส DBConnection { ส่วนตัว DB mongoDB; DBConnection() { super(); } @PostConstruct โมฆะสาธารณะ afterCreate() { String mongoHost = "127.0.0.1" String mongoPort = "27001" String mongoUser = "strongloop; String mongoPassword = "rocks"; String mongoDBName = "restexample" ; int port = จำนวนเต็ม.decode(mongoPort); Mongo mongo = null; ลอง { mongo = new Mongo(mongoHost, port); } catch (UnknownHostException e) { System.out.println("ไม่สามารถเชื่อมต่อกับ MongoDB: " + e.getMessage() + " :: " + e. getClass()); } mongoDB = mongo.getDB(mongoDBName); ถ้า (mongoDB.authenticate(mongoUser, mongoPassword.toCharArray()) == false) { System.out.println("ล้มเหลวในการตรวจสอบความถูกต้องของฐานข้อมูล "); } } ฐานข้อมูลสาธารณะ getDB() { return mongoDB } }

ขั้นตอนที่ 4: นำเข้าข้อมูลไปยัง MongoDB (mmmm เบียร์)

ในโครงการของเรา เราต้องการโหลดรายการเบียร์ทั้งหมดที่มีชื่อ Pabst หากคุณยังใหม่กับอุตสาหกรรมเบียร์ คุณอาจต้องการลอง American Light Ale ของ Pabst Brewing เบียร์เหล่านี้มีริบบิ้นสีน้ำเงินและลวดลายของ Colt รวมถึงเครื่องดื่มมอลต์ทุกประเภท

ขั้นแรก คุณต้องดาวน์โหลดไฟล์ json ที่มีข้อมูลทั้งหมดที่ต้องส่งคืน คุณสามารถใช้ URL ต่อไปนี้เพื่อให้บรรลุเป้าหมายนี้:
https://dl.dropboxusercontent.com/u/72466829/beers.json

หลังจากดาวน์โหลดแล้ว ให้ใช้คำสั่ง mongoimport เพื่อนำเข้าฐานข้อมูล คำสั่งมีดังนี้:

 $ mongoimport --jsonArray -d yourDBName -c เบียร์ -- พิมพ์ json --file /tmp/beers.json -h yourMongoHost -- พอร์ต yourMongoPort -u yourMongoUsername -p yourMongoPassword

คุณสามารถดูผลลัพธ์ต่อไปนี้:

 เชื่อมต่อกับ: 127.0.0.1:27017 อังคาร 10 มิ.ย. 20:09:55.436 ตรวจสอบ 9 24 อังคาร 10 มิ.ย. 20:09:55.437 นำเข้าวัตถุ 24 รายการ

ขั้นตอนที่ 5: สร้างวัตถุโมเดลเบียร์

เราได้สร้างคลาสการเชื่อมต่อฐานข้อมูลและโหลดข้อมูลเบียร์ลงในฐานข้อมูล MongoDB ถึงเวลาสร้างออบเจ็กต์แบบจำลองเพื่อควบคุมข้อมูลเบียร์ของเรา สร้างไฟล์ใหม่ชื่อ Beer.java และวางไว้ในไดเร็กทอรี /src/main/java/com/strongloop/data หลังจากสร้างไฟล์แล้ว ให้เพิ่มโค้ดต่อไปนี้ลงไป:

 แพ็คเกจ com.strongloop.data; คลาสสาธารณะ { สตริงส่วนตัว ชื่อ; สตริงสาธารณะ getId () { return id; } สตริงสาธารณะ getName() { return name; } public void setName(String name) { this.name = name; } สาธารณะ String getDescription() { กลับคำอธิบาย; } public void setDescription (คำอธิบายสตริง) this.description = คำอธิบาย; }}

หมายเหตุ: ไฟล์ JSON ที่ให้มามีข้อมูลเพิ่มเติมที่เราจะใช้ ดังนั้นให้ลองดูและเพิ่มฟังก์ชันพิเศษบางอย่างลงไปเพื่อขยายประสบการณ์การเรียนรู้ของคุณ

ขั้นตอนที่ 6: สร้างบริการ REST

คาดเดาว่าจะทำอย่างไร? ตกลง ในที่สุดเราก็พร้อมที่จะสร้างบริการเว็บที่ใช้ REST ซึ่งจะช่วยให้เราสามารถโหลดข้อมูลเบียร์ในขั้นตอนก่อนหน้าได้ ในการดำเนินการนี้ เราจำเป็นต้องสร้างไฟล์ใหม่ชื่อ BeerWS.java และวางไว้ในไดเร็กทอรี /src/main/java/com/strongloop/webservice หลังจากสร้างแล้ว ให้เพิ่มโค้ดต่อไปนี้:

 แพ็คเกจ com.strongloop.webservice; นำเข้า java.util.ArrayList; นำเข้า java.util.List; นำเข้า javax.enterprise.context.RequestScoped; นำเข้า javax.inject.Inject; นำเข้า javax.ws.rs.GET; นำเข้า javax.ws .rs.Path;นำเข้า javax.ws.rs.Produces;นำเข้า javax.ws.rs.QueryParam;นำเข้า com.strongloop.data.DBConnection;นำเข้า com.strongloop.data.Beer;นำเข้า com.mongodb.BasicDBObject;นำเข้า com.mongodb.DB;นำเข้า com.mongodb.DBCollection;นำเข้า com.mongodb.DBCursor;นำเข้า com.mongodb. DBObject; @RequestScoped@Path("/beers") คลาสสาธารณะ BeerWS { @Inject DBConnection dbConnection; DBCollection getBeerCollection() { DB db = dbConnection.getDB(); DBCollection BeerCollection = db.getCollection("เบียร์"); เบียร์ส่วนตัว populateBeerInformation (DBObject dataValue) { เบียร์ theBeer = เบียร์ใหม่ (); theBeer.setName(dataValue.get("name")); theBeer.setDescription(dataValue.get("ชื่อ")); theBeer.setId(dataValue.get("_id").toString() } // รับเบียร์ทั้งหมด @GET() @Produces("application/json") public List<Beer> getAllBeers() { ArrayList<Beer> allBeersList = new ArrayList<Beer>(); DBCollection beers = this.getBeerCollection(); เคอร์เซอร์ DBCursor = beers.find(); ลอง { while (cursor.hasNext()) { allBeersList.add(this.populateBeerInformation(cursor.next) ())); } } ในที่สุด { cursor.close(); } กลับ allBeersList;

ขั้นตอนที่ 7: ค้นหาข้อมูลเบียร์ Silly

โอ้เสร็จแล้ว เราได้เขียนบริการ REST ที่สามารถดึงข้อมูลเบียร์ทั้งหมดจากฐานข้อมูลได้ ตอนนี้เพื่อปรับใช้โค้ดของคุณกับแอปพลิเคชันเซิร์ฟเวอร์ของคุณ ให้เปิดที่อยู่ต่อไปนี้ในเบราว์เซอร์ของคุณเพื่อดูว่าทำงานได้ดีหรือไม่:
http://yourserverlocation/ws/beers

หากทุกอย่างเรียบร้อยดี คุณจะเห็นรายการข้อมูลเบียร์ทั้งหมดดังที่แสดงด้านล่าง:

สร้างแอปพลิเคชันโหนด

หากคุณทำตามขั้นตอนข้างต้นเพื่อเขียนโปรแกรมด้วย java คุณจะรู้ว่าแม้ว่าการสร้างแอปพลิเคชันโดยใช้ javaEE จะดำเนินไปอย่างรวดเร็ว แต่ก็ยังเป็นเรื่องยากมากในการสร้างแอปพลิเคชันง่ายๆ เช่น บริการ REST อย่าเข้าใจฉันผิด ฉันยังคงชอบใช้ javaEE แต่พบว่าสำหรับหลายๆ สถานการณ์ เช่น การสร้างบริการ REST ที่ส่งคืนข้อมูล json โหนดจะเหมาะสมกว่า ต่อไป เราจะสร้างบริการเว็บแบบง่ายๆ โดยใช้ LoopBack API ของ StrongLoop นอกจากนี้ ฉันจะแสดงวิธีการติดตั้ง Node บน Apple OSX ให้คุณดู

ขั้นตอนที่ 1: ติดตั้ง Node

วิธีที่ง่ายที่สุดในการติดตั้ง Node คือผ่านแพ็คเกจไบนารีที่เข้ากันได้กับระบบปฏิบัติการส่วนใหญ่ เปิดเบราว์เซอร์ของคุณและเยี่ยมชมหน้าเว็บด้านล่างเพื่อดาวน์โหลดเวอร์ชันที่เกี่ยวข้องตามระบบปฏิบัติการของคุณ:
http://nodejs.org/download/

หลังจากการดาวน์โหลดเสร็จสิ้น คุณจะเห็นสิ่งต่อไปนี้:

หากคุณใช้ Mac OSX ให้คลิกที่ไฟล์ .pkg ทั่วไป เพื่อบันทึกตัวติดตั้งลงในคอมพิวเตอร์ของคุณ หลังจากดาวน์โหลดไฟล์แล้ว ให้ดับเบิลคลิกเพื่อเริ่มโปรแกรมการติดตั้ง คุณจะเห็นกล่องโต้ตอบการติดตั้งต่อไปนี้:

ดำเนินการติดตั้งต่อตามค่าเริ่มต้น หลังจากติดตั้งสำเร็จ ให้คลิกปุ่มปิดเพื่อออกจากโปรแกรมการติดตั้ง

ค่อนข้างง่ายใช่มั้ย?

ขั้นตอนที่ 2: ติดตั้ง LoopBack โดยใช้ NPM

เมื่อติดตั้ง Node ในระบบโลคัลแล้ว ขั้นตอนต่อไปคือการติดตั้งแพ็คเกจ LoopBack ที่ StroopLoop มอบให้ LoopBack เป็นแพ็คเกจซอร์สโค้ด API แบบเปิด เมื่อคุณเรียนรู้การใช้ Node เพื่อพัฒนาและปรับใช้ซอฟต์แวร์ LoopBack จะทำให้การเขียนโปรแกรมง่ายขึ้น

ในการติดตั้ง LoopBack เราจะใช้บรรทัดคำสั่ง npm ซึ่งเป็นส่วนหนึ่งของภาษาโหนดหลัก NPM เป็นเครื่องมือการจัดการแพ็คเกจอย่างเป็นทางการที่ใช้ในการติดตั้งคลาสไลบรารีหรือเทมเพลตที่แอปพลิเคชันขึ้นอยู่กับ หากคุณเป็นโปรแกรมเมอร์ Java คุณสามารถเปรียบเทียบ NPM กับ Maven ได้ การใช้ Maven เพื่อสร้างโปรเจ็กต์ นักพัฒนาสามารถกำหนดค่าแพ็กเกจ jar หรือเทมเพลตที่โปรเจ็กต์ต้องพึ่งพาใน pom.xml เมื่อโปรเจ็กต์เริ่มคอมไพล์ Maven จะดาวน์โหลดไฟล์ที่ต้องพึ่งพาทั้งหมดและแนะนำแพ็คเกจ jar ลงในโปรเจ็กต์ NPM ทำงานเหมือนกับ Maven สำหรับโปรเจ็กต์พิเศษบางโปรเจ็กต์ จะใช้ไฟล์ package.json เพื่อกำหนดค่าไฟล์ที่โปรเจ็กต์นั้นใช้อยู่ คุณยังสามารถใช้บรรทัดคำสั่งเพื่อดาวน์โหลดไฟล์ที่ต้องพึ่งพาไปยังระบบโลคัลได้ หากคุณไม่เข้าใจสิ่งนี้ ไม่ต้องกังวล เราจะอธิบายไฟล์ package.json อย่างละเอียดในขั้นตอนถัดไป

ในการติดตั้ง LoopBack เราใช้บรรทัดคำสั่งง่ายๆ เพื่อดาวน์โหลดและติดตั้งไฟล์ที่ต้องพึ่งพาทั้งหมด เปิดหน้าต่างบรรทัดคำสั่งของหน้าต่างแล้วป้อนคำสั่งต่อไปนี้:

 $ npm ติดตั้ง -g strongloop

เคล็ดลับ: ระหว่างการติดตั้ง คุณอาจต้องใช้บัญชีผู้ใช้อื่นเพื่อรันคำสั่งนี้

บรรทัดคำสั่งนี้หมายถึงอะไร? พารามิเตอร์ -g แจ้ง npm ว่าเราต้องการติดตั้งแพ็คเกจ strong-cli พารามิเตอร์ -g ทำให้แพ็คเกจนี้เข้ากันได้กับระบบและแอปพลิเคชันใด ๆ เมื่อคุณรันคำสั่งข้างต้น NPM จะดาวน์โหลดไฟล์ที่เกี่ยวข้องทั้งหมด เวลาในการดาวน์โหลดขึ้นอยู่กับความเร็วอินเทอร์เน็ตของคุณและอาจใช้เวลาหลายนาที

ขั้นตอนที่ 3: สร้างแอปพลิเคชัน

การสร้างแอปพลิเคชันโดยใช้ LoopBack API นั้นง่ายดาย เปิดหน้าต่างบรรทัดคำสั่งของหน้าต่างของคุณ และใช้คำสั่งต่อไปนี้เพื่อสร้างตัวอย่างแอปพลิเคชันใหม่

 $ slc วนกลับ

จากนั้นระบบจะแจ้งชื่อเส้นทางรูทของโปรเจ็กต์ ในตัวอย่างนี้ จะใช้ตัวอย่างตัวอย่าง ถัดไปจะแจ้งชื่อแอปพลิเคชัน ใช้ตัวอย่างเริ่มต้น

คำสั่ง slc ได้สร้างแอปพลิเคชัน LoopBack ชื่อ restexample และกำหนดค่าแอปพลิเคชันแล้ว หากคุณดำเนินการคำสั่งข้างต้นอีกครั้งและยังคงใช้ตัวอย่างใหม่เพื่อตั้งชื่อ LoopBack จะสร้างไดเร็กทอรีใหม่ คุณสามารถใช้คำสั่ง cd เพื่อแก้ไขเส้นทางรูทของแอปพลิเคชัน

 ตัวอย่างตัวอย่าง $ cd

ตอนนี้เราได้สร้างแอปพลิเคชันแล้ว เราจะกำหนดค่า MongoDB เป็นแหล่งข้อมูลสำหรับแอปพลิเคชัน

ขั้นตอนที่ 4: กำหนดแหล่งข้อมูล

ในการเชื่อมต่อกับ MongoDB เราจำเป็นต้องเพิ่มแหล่งข้อมูลให้กับแอปพลิเคชันและรันคำสั่งต่อไปนี้:

 $ slc ลูปแบ็ค: แหล่งข้อมูล

ที่พรอมต์ป๊อปอัป คุณสามารถป้อนชื่อแหล่งข้อมูลที่กำหนดเองได้ที่นี่ เลือก myMongo

 [?] ป้อนชื่อแหล่งข้อมูล: myMongo

วิธีนี้เราจะแนบคำจำกัดความแหล่งข้อมูลของแบ็กเอนด์เข้ากับตัวเชื่อมต่อจริงที่ขับเคลื่อนโดย StrongLoop ที่นี่เราเลือกตัวเชื่อมต่อ MongoDB จากรายการ

 [?] เลือกตัวเชื่อมต่อสำหรับ myMongo:PostgreSQL (สนับสนุนโดย StrongLoop)Oracle (สนับสนุนโดย StrongLoop)Microsoft SQL (สนับสนุนโดย StrongLoop)MongoDB (สนับสนุนโดย StrongLoop)เว็บเซอร์วิส SOAP (สนับสนุนโดย StrongLoop)บริการ REST (สนับสนุนโดย StrongLoop)Neo4j ( จัดทำโดยชุมชน) (เลื่อนขึ้นและลงเพื่อดูตัวเลือกเพิ่มเติม)

ขั้นตอนที่ 5: ชี้ไปที่แหล่งข้อมูลจริง

ในการเชื่อมต่อกับ MongoDB เราจำเป็นต้องชี้ไปที่อินสแตนซ์ MongoDB จริง กำหนดข้อมูลการกำหนดค่าแหล่งข้อมูลทั้งหมดในไฟล์ datasource.json ไฟล์นี้อยู่ในไดเร็กทอรีรูท/เซิร์ฟเวอร์ของแอปพลิเคชัน ดังนี้ MongoDB เพิ่มแหล่งข้อมูล:

 { "db": { "ชื่อ": "db", "ตัวเชื่อมต่อ": "หน่วยความจำ" }, "myMongo": { "ชื่อ": "myMongo", "ตัวเชื่อมต่อ": "mongodb" "url": "mongodb: //localhost:27017/restexample" }}

หมายเหตุ: ตรวจสอบให้แน่ใจว่าได้ระบุ URL การเชื่อมต่อที่ถูกต้องให้กับฐานข้อมูล MongoDB สำหรับตัวอย่างนี้ ฉันได้สร้างฐานข้อมูลชื่อ restexample ซึ่งใช้เป็นแหล่งข้อมูล

ขั้นตอนที่ 6: นำเข้าข้อมูลไปยัง MongoDB (mmmmm เบียร์)

ดังที่ได้กล่าวไว้ในส่วนของ Java ของบทความนี้ เราจำเป็นต้องโหลดชุดข้อมูลลงในฐานข้อมูล MongoDB หากคุณได้ทำตามขั้นตอนนี้ตามวิธีที่กล่าวถึงในบทความนี้แล้ว และจากนั้นวางแผนที่จะใช้ฐานข้อมูลเดียวกัน คุณสามารถละเว้นขั้นตอนนี้ได้ 6 และข้ามไปยังขั้นตอนที่ 7 โดยตรง

ขั้นแรก คุณต้องดาวน์โหลดไฟล์ JSON ที่มีข้อมูลทั้งหมดที่จะส่งคืน ซึ่งสามารถรับได้จาก URL ต่อไปนี้:
https://dl.dropboxusercontent.com/u/72466829/beers.json

หลังจากดาวน์โหลดไฟล์ชุดข้อมูลแล้ว ให้ใช้คำสั่ง mongoimport ต่อไปนี้โดยตรงเพื่อโหลดลงในฐานข้อมูล:

 $ mongoimport --jsonArray -d yourDBName -c เบียร์ -- ประเภท json --file /tmp/beers.json -h yourMongoHost --port

คุณควรเห็นผลลัพธ์ต่อไปนี้:

 เชื่อมต่อกับ: 127.6.189.2:27017อังคาร 10 มิ.ย. 20:09:55.436 ตรวจสอบ 9 24อังคาร 10 มิ.ย. 20:09:55.437 นำเข้าวัตถุ 24 รายการ

ขั้นตอนที่ 7: สร้างโมเดลเบียร์ของเราเอง

ในโลก Java เราสามารถนึกถึงวัตถุโมเดลได้ มันแสดงถึงวัตถุนี้ แต่ที่นี่ วัตถุนี้คือเบียร์ LoopBack ให้วิธีง่ายๆ ในการสร้างวัตถุแบบจำลองผ่านบรรทัดคำสั่ง ป้อนคำสั่งต่อไปนี้:

 $ slc ลูปแบ็ค: model

นี่จะเป็นการเปิดเซสชันแบบโต้ตอบเพื่อกำหนดแบบจำลอง สิ่งแรกที่คุณต้องป้อนคือชื่อแบบจำลอง ป้อน "เบียร์" ที่นี่ จากนั้นคุณจะได้รับพร้อมท์ให้ระบุแหล่งข้อมูลที่ควรแนบแบบจำลองนี้ที่นี่ แหล่งข้อมูล myMongo ที่สร้างขึ้นก่อนหน้านี้

 [?] ป้อนชื่อรุ่น: เบียร์[?] เลือกแหล่งข้อมูลที่จะแนบเบียร์ไปที่:db (หน่วยความจำ)myMongo (mongodb)

จากนั้นระบบจะแจ้งว่าต้องเปิดเผย API นี้ผ่าน REST หรือไม่ แน่นอนว่าเราหวังเช่นนั้น

 [?] เปิดเผยเบียร์ผ่าน REST API ใช่หรือไม่

สุดท้าย เลือกชื่อพหูพจน์เครือข่ายสำหรับโมเดล ในที่นี้โมเดลมีชื่อว่า Beer ดังนั้นพหูพจน์คือ bean (ค่าเริ่มต้น)

 [?] รูปแบบพหูพจน์ที่กำหนดเอง (ใช้เพื่อสร้าง URL REST):

ต่อไปคุณจะได้รับแจ้งให้กำหนดคุณสมบัติของโมเดล สำหรับโปรแกรมตัวอย่างนี้ เราจะเน้นไปที่ชื่อและคำอธิบายของเบียร์

 ป้อนชื่อคุณสมบัติว่างเมื่อเสร็จแล้ว[?] ชื่อคุณสมบัติ: ชื่อ

ตราบใดที่คุณกด Enter คุณจะได้รับแจ้งให้ป้อนประเภทข้อมูลของแอตทริบิวต์ที่ระบุแต่ละรายการ ให้เลือกประเภทสตริงที่นี่ จากนั้นกด

 Enter.[?] ประเภทคุณสมบัติ: (ใช้ปุ่มลูกศร)stringnumberbooleanobjectarraydatebuffergeopoint(other)

ถัดไป ให้สร้างแอตทริบิวต์คำอธิบายในลักษณะเดียวกัน จากนั้นคุณจะถูกขอให้ป้อนประเภทข้อมูล นอกจากนี้ยังเป็นประเภทสตริง เลือกตัวเลือกสตริง จากนั้นคลิก

 Enter มาเพิ่มคุณสมบัติเบียร์อื่น ป้อนชื่อคุณสมบัติว่างเมื่อทำเสร็จแล้ว[?] ชื่อคุณสมบัติ: descriptioninvoke loopback:property[?] ประเภทคุณสมบัติ: string[?] จำเป็น?

ขอแสดงความยินดี คุณได้สร้างออบเจ็กต์โมเดลโดยใช้ LoopBack ร่วมกับ Node เรียบร้อยแล้ว หากคุณต้องการดูสิ่งที่ถูกสร้างขึ้นจริงในระหว่างกระบวนการนี้ คุณสามารถเปิดไฟล์ Beer.json ที่อยู่ในไดเร็กทอรี root/common/models ของแอปพลิเคชัน แล้วเลื่อนไปที่ ท้ายไฟล์ คุณจะเห็นโมเดลดังนี้:

 { "name": "เบียร์", "base": "PersistedModel", "properties": { "name": { "type": "string", "required": true }, "description": { "type" : "string", "required": true } }, "การตรวจสอบความถูกต้อง": [], "ความสัมพันธ์": {}, "acls": [], "วิธีการ": []}

ดังที่คุณเห็นที่นี่ เราได้สร้างโมเดลแล้ว และในขณะเดียวกันก็มีการกำหนดแอตทริบิวต์ชื่อและคำอธิบายให้กับโมเดลนี้แล้ว

ในไฟล์ /server/model-config.js คุณจะสังเกตเห็นว่าไฟล์มีฟิลด์เพิ่มเติมบางส่วน รวมถึงสาธารณะและแหล่งข้อมูล ฟิลด์สาธารณะระบุว่าเราต้องการเปิดเผยโมเดลนี้สู่ภายนอกผ่านบริการเครือข่าย REST ฟิลด์คือระบุแหล่งข้อมูลที่จะใช้สำหรับการดำเนินการ CRUD ในแบบจำลองนี้

 "เบียร์": { "dataSource": "myMongo", "สาธารณะ": จริง }

ขั้นตอนที่ 8: ดื่มด่ำไปกับความสุขในการชมเบียร์

ยินดีด้วย คุณได้สร้างแอปพลิเคชัน Node.js ตัวแรกที่มีบริการเว็บ REST ที่สามารถรับข้อมูลเบียร์ได้ สุดท้ายนี้ สิ่งที่เราต้องทำคือปรับใช้แอปพลิเคชัน

โชคดีที่การปรับใช้นั้นง่ายดายอยู่แล้ว โดยดำเนินการคำสั่งต่อไปนี้ในไดเรกทอรีรากของแอปพลิเคชัน:

 $ slc วิ่ง

ทันทีที่แอปพลิเคชันทำงาน คุณสามารถยืนยันได้ว่าการปรับใช้สำเร็จหรือไม่โดยไปที่ URL ต่อไปนี้ด้วยเบราว์เซอร์ของคุณ:

http://0.0.0.0:3000/api/beers

ค่อนข้างเจ๋งใช่มั้ย?

LoopBack ยังมีหน้าที่ให้คุณดูบริการที่มีอยู่ทั้งหมดของแอปพลิเคชัน รวมถึงโมเดล Beer และบริการ REST ที่เราสร้างขึ้น ชี้เบราว์เซอร์ของคุณไปที่ URL ต่อไปนี้เพื่อดู:

http://0.0.0.0:3000/นักสำรวจ

หลังจากที่โหลดเพจสำเร็จแล้ว คุณจะเห็นอินเทอร์เฟซต่อไปนี้ เราได้สร้างโหนด bean ซึ่งเป็นส่วนหนึ่งของบล็อก ฉันได้เน้นจุดสิ้นสุดของ /beers แล้ว:

คุณสามารถคลิก /beers เพื่อขยาย API ที่มีอยู่ คุณสามารถใช้งานและทดสอบได้ ดังแสดงในรูปด้านล่าง:

สรุปแล้ว

ในบล็อกโพสต์นี้ ฉันจะแสดงวิธีใช้ Java EE เพื่อสร้างบริการ REST ที่ส่งคืนข้อมูลรายการผลิตภัณฑ์เบียร์จาก Pabst Beer Company ต่อมา ฉันใช้ node.js และเฟรมเวิร์กลูปแบ็คที่ใช้ node.js เพื่อใช้บริการส่วนที่เหลือด้วยฟังก์ชันเดียวกันโดยใช้โค้ดเพียงเล็กน้อย สิ่งที่สำคัญที่สุดคือ LoopBack API ยังมีการใช้งานเริ่มต้นสำหรับการเพิ่ม การลบ การตรวจสอบ และการแก้ไขเอนทิตีเบียร์ เพื่อให้เราสามารถรับบริการส่วนที่เหลือด้วยฟังก์ชันการเพิ่ม การลบ การตรวจสอบ และการแก้ไขที่สมบูรณ์โดยไม่ต้องเขียนบรรทัดเดียว ของรหัส

รายการต่อไปนี้เปรียบเทียบคุณสมบัติที่เกี่ยวข้องของ javaEE และ node.js ที่กล่าวถึงในโพสต์บล็อก:

อะไรต่อไป?

Node v0.12 ที่กำลังจะมาถึงจะนำเสนอฟีเจอร์ใหม่ที่น่าตื่นเต้นอย่างน้อย 8 รายการ ฟีเจอร์เหล่านั้นจะเป็นอย่างไร? ไปที่หน้า "มีอะไรใหม่ใน Node.js v0.12" เพื่อเรียนรู้เพิ่มเติม
สนใจการฝึกอบรมและการรับรองที่เกี่ยวข้องกับโหนดหรือไม่ StrongLoop เสนอบริการที่หลากหลายเพื่อตอบสนองความต้องการของคุณ