CÀI ĐẶT MẠNG XÃ HỘI VỚI NEO4J - ỨNG DỤNG SOCIAL NETWORK WORKSHOP USING NEO4J
Bạn đang xem bản rút gọn của tài liệu. Xem và tải ngay bản đầy đủ của tài liệu tại đây (1.07 MB, 59 trang )
Xây dựng mạng xã hội với Neo4j
Contents
LỜI MỞ ĐẦU..................................................................................................................3
PHẦN I. TỔNG QUAN VỀ CƠ SỞ DỮ LIỆU ĐỒ THỊ..............................................4
I. Khái quát đồ thị..............................................................................................................4
II. Cơ sở dữ liệu đồ thị.......................................................................................................4
III. Ứng dụng của cơ sở dữ liệu đồ thị..............................................................................6
PHẦN II. NEO4J TRONG VIỆC CÀI ĐẶT MẠNG XÃ HỘI...................................6
I. Neo4j là một cơ sở dữ liệu đồ thị...................................................................................6
II. Sử dụng Neo4j vào các ứng dụng java.......................................................................11
IV. Sử dụng API REST từ Java.......................................................................................13
V. Tạo một đồ thị với REST API từ Java........................................................................13
VI. Khởi động server.......................................................................................................13
VII. Tạo một node............................................................................................................14
VIII. Thêm thuộc tính......................................................................................................15
IX. Thêm quan hệ............................................................................................................16
X. Thêm thuộc tính vào một quan hệ..............................................................................17
XI. Truy vấn đồ thị..........................................................................................................17
XII. Framework duyệt đồ thị Java API...........................................................................20
XIII. Giải thuật đồ thị......................................................................................................24
XIV. Ví dụ về giải thuật đồ thị........................................................................................24
XV. Xây dựng giải thuật đồ thị.......................................................................................26
xvi. Tìm tất cả đường đi ngắn nhất..................................................................................26
xvii. Tìm một trong những đường đi ngắn nhất giữa những node..................................28
xviii. Thực thi giải thuật Dijkstra với cùng trọng lượng của mối quan hệ.....................31
xix. Giải thuật Dijkstra với trọng lượng quan hệ khác nhau...........................................33
XX. Cài đặt và triển khai.................................................................................................34
XXI. Server......................................................................................................................34
XXII. Nhúng vào (embedded).........................................................................................35
XXIII. Cài đặt..................................................................................................................35
XXIV. Cài đặt một ứng dụng..........................................................................................35
XXV. Quản trị bằng web.................................................................................................36
PHẦN III : CÀI ĐẶT MẠNG XÃ HỘI VỚI NEO4J - ỨNG DỤNG SOCIAL NETWORK
WORKSHOP USING NEO4J......................................................................................41
I. Giới thiệu......................................................................................................................41
XXVI. Bước 1 – cơ bản về mạng xã hội.........................................................................41
XXVII. Bước 2 – Thêm những kiểu quan hệ..................................................................45
HVTH: Nguyễn Xuân Nghề
Trang: 1
Xây dựng mạng xã hội với Neo4j
XXVIII. Bước 3 – giới hiệu chỉ mục cho mạng xã hội...................................................46
XXIX. Giới thiệu domain API.........................................................................................47
XXX. Bước 5 – giải thuật đồ thị......................................................................................48
XXXI. Bước 6 – Sự đề cử...............................................................................................49
II. Cách cài đặt.................................................................................................................49
1. Junit Test Bước 1.........................................................................................................49
2. Junit Test Bước 2.........................................................................................................51
3. Junit test bước 3...........................................................................................................52
4. Junit test bước 4...........................................................................................................53
5. Junit test bước 5...........................................................................................................54
6. Junit test bước 6...........................................................................................................55
KẾT LUẬN....................................................................................................................57
TÀI LIỆU THAM KHẢO.............................................................................................59
HVTH: Nguyễn Xuân Nghề
Trang: 2
Xây dựng mạng xã hội với Neo4j
LỜI MỞ ĐẦU
Ngày nay, hầu hết các ứng dụng đều có một lượng dữ liệu khổng lồ.Vấn đề lưu trữ và xử
lý dữ liệu trở nên khó khăn và cần được quan tâm hơn, dữ liệu linh hoạt và được thay đổi
gần như theo thời gian thậm chí thay đổi cấu trúc cơ bản của dữ liệu. Việc xử lý đòi hỏi
phải linh hoạt và không làm gián đoạn ứng dụng.Với hệ thống lưu trữ hiện tại khơng thể
linh động với địi hỏi này.
Người sử dụng muốn có một cầu nối, một biện pháp để giải quyết những vấn đề trên do
đó dữ liệu đồ thị ra đời..Dữ liệu đồ thị là cách thức lưu trữ thông tin ở dạng đồ thị những
đỉnh và cạnh.Với cách thức lưu trữ này, việc quản lý dữ liệu trở nên mềm dẽo và dễ dàng
hơn ngay cả trong việc ứng dụng tri thức vào khối dữ liệu lưu trữ.
Tiểu luận này là sự trình bày khái quát về cơ sở dữ liệu đồ thị với Neo4j, đồng thời trình
bày trình bày một cách chi tiết việc tạo một đồ thị Neo4j bằng Java API và ứng dụng cài
đặt mạng xã hội đơn giản với Neo4j
Em xin chân thành cảm ơn PGS.TS. Đỗ Phúc – Giảng viên môn học cơ sở dữ liệu nâng
cao đã truyền đạt những kiến thức vô cùng quý báu, xin chân thành cám ơn ban cố vấn
học tập và ban quản trị chương trình đào tạo thạc sĩ Cơng nghệ thơng tin qua mạng của
Đại Học Quốc Gia TPHCM đã tạo điều kiện về tài liệu tham khảo để em có thể hồn
thành môn học này.
Chân thành cám ơn!
Nguyễn Xuân Nghề
HVTH: Nguyễn Xuân Nghề
Trang: 3
Xây dựng mạng xã hội với Neo4j
PHẦN I. TỔNG QUAN VỀ CƠ SỞ DỮ LIỆU ĐỒ THỊ
I.
Khái quát đồ thị
Đồ thị là một tập các đối tượng được gọi là các đỉnh được nối với nhau bởi các
cạnh.Có 2 loại đồ thị : đồ thị vô hướng và đồ thị có hướng.
Đồ thị vơ hướng
Đồ thị có hướng
Cấu trúc đồ thị có thể mở rộng bằng cách gán trọng số cho các cạnh của đồ thị. Có thể
sử dụng đồ thị trọng số để biểu diễn những khái niệm khác nhau như chiều dài con
đường,thời gian đi giữa hai nút, độ mạnh liên kết giữa các nút, số giao tác kết nối giữa 2
nút ở một thời điểm nào đó…
Nhiều bài tốn thực tế có thể được biểu diễn bằng đồ thị. Ví dụ, cấu trúc liên kết của
một website có thể được biểu diễn bằng một đồ thị có hướng, XML, cấu trúc phân tử hóa
học, cấu trúc protein, đối tượng 3D…
II.
Cơ sở dữ liệu đồ thị
a. Giới thiệu :
Cơ sở dữ liệu đồ thị là tập các đồ thị.Một cơ sở dữ liệu đồ thị có thể có nhiều đồ
thị nhưng cũng có thể chỉ có một đồ thị, đó là một đồ thị rất lớn chứa nhiều nút và
đỉnh ví dụ như mạng xã hội
HVTH: Nguyễn Xuân Nghề
Trang: 4
Xây dựng mạng xã hội với Neo4j
b. Cách lưu trữ dữ liệu đồ thị :
Lưu trữ bằng RDBMS
Dữ liệu được lưu trữ thành những dòng và cột trong những table khác nhau.Dữ
liệu được truy xuất bằng câu lệnh SQL. SQL cho phép người sử dụng truy xuất khá
mạnh mẽ dữ liệu đồ thị bao gồm cả việc trích xuất dữ liệu mới từ dữ liệu đã lưu trữ .
Mặc dù có nhiều điểm mạnh nhưng SQL khơng thể hổ trợ những thao tác tính
tốn, những biểu thức phức tạp một cách linh hoạt và tùy lúc.Ví dụ như tính chi phí một
con đường đi từ đỉnh này để đỉnh khác, tìm chi phí thấp nhất để đi giữa hai nút cho
trước…
Lưu trữ bằng SBGE
Để giải quyết vấn đề trên DB2 và RDBMS đã mở rộng SQL bằng cách xây dựng
nhưng hàm cụ thể được gọi là user-defined functions (UDFs). UDFs được sử dụng mọi
nơi mà người sử dụng muốn.
SBGE sử dụng những hàm mở rộng của DB2 để thao tác trên dữ liệu đồ thị.Với
SBGE có thể dễ dàng quản lý dữ liệu đồ thị thông qua các nút, cạnh.
Với RDBMSs cho phép người sử dụng định nghĩa cũng như tìm kiếm những đồ
thị con. RDBMSs có thể linh hoạt trên một đồ thị dữ liệu lớn bởi vì SQL có thể tìm kiếm
mà khơng địi hỏi việc load cả dữ liệu đồ thị lên bộ nhớ tạm. Do đó, SBGE chính là sự
kết hợp giữa SQL để quản lý dữ liệu của đồ thị và những hàm mở rộng để quản lý những
hàm truy xuất của đồ thị.
Lưu trữ bằng neo4j
Neo4j là một cơ sở dữ liệu nổi tiến hiện nay. Tiểu luận này sẽ trình bày chi tiết
cách sử dụng neo4j để xây dựng mạng xã hội.
HVTH: Nguyễn Xuân Nghề
Trang: 5
Xây dựng mạng xã hội với Neo4j
III.
Ứng dụng của cơ sở dữ liệu đồ thị
Dữ liệu đồ thị có nhiều ứng dụng trong thực tế như : trong sinh học (dùng cơ sở dữ
liệu đồ thị để lưu trữ cấu trúc genes, protein hoặc mơ hình của một tế bào…), trong hóa
học ( Cấu trúc phân tử của một chất), lưu trữ ảnh, mạng xã hội, cấu trúc liên kết
website…
PHẦN II. NEO4J TRONG VIỆC CÀI ĐẶT MẠNG XÃ HỘI
I.
Neo4j là một cơ sở dữ liệu đồ thị
Neo4j là một cơ sở dữ liệu đồ thị mã nguồn mở. Làm việc với nó ứng dụng chúng ta sẽ
được hiển thị như một đồ thị.
1. Nodes
Dạng cơ bản của một đồ thị là những nodes và những quan hệ. Trong neo4j, cả node và
quan hệ đều chứa đựng thuộc tính.
Node thường dùng để hiển thị những thực thể, nhưng tùy theo lĩnh vực mối quan hệ mà
có thể sử dụng cho mục đích này
2. Mối quan hệ
Mối quan hệ giữa các node là phần quan trọng chủ chốt của cơ sở dữ liệu đồ thị.
Chúng cho phép ta tìm kiến những dữ liệu liên quan. Giống như nodes, mối quan
hệ cũng có thể có thuộc tính
HVTH: Nguyễn Xn Nghề
Trang: 6
Xây dựng mạng xã hội với Neo4j
Một liên hệ liên kết 2 nodes, và tạo ra một điểm bắt đầu node và điểm kết thúc
node
Những mối quan hệ luôn luôn có hướng, chúng có thể hiển thị mối liên hệ đến một
node (incoming relationship) hoặc mối liên hệ đi từ một node(outgoing
relationship)
3. Thuộc tính
Cả hai nodes và mối liên hệ có thể có những thuộc tính. Thuộc tính là những cặp
key-value, trong đó key là chuổi. giá trị của thuộc tính có thể là chuỗi, integer
mảng integer…
HVTH: Nguyễn Xn Nghề
Trang: 7
Xây dựng mạng xã hội với Neo4j
4. Đường dẫn
Một đường dẫn là một hoặc nhiều nodes với những mối quan hệ được liên kết với
nhau, nó được hiển thị khi thực hiện một câu truy vấn hoặc một kết quả duyệt đồ
thị.
5. Duyệt đồ thị
HVTH: Nguyễn Xuân Nghề
Trang: 8
Xây dựng mạng xã hội với Neo4j
Duyệt đồ thị nghĩa là duyệt qua những nodes của đồ thị theo những mối quan hệ
với những luật có sẳng. Trong hầu hết trường hợp chỉ có đồ thị con được duyệt
qua
Neo4j có traversal API sẽ giúp chúng ta xác định những luật để duyệt đồ thị. Ở
mức độ cơ bản ta có duyệt theo chiều rộng và duyệt theo chiều sâu.
6. Mô hình mạng xã hội
Mạng xã hội(được biết như là một đồ thị xã hội trên web) thực tế nó như là một mơ
hình của đồ thị. Ví dụ này sẽ trình bày một mơ hình mạng xã hội đơn giản có chứa
thơng tin về những người bạn kết nối với nhau và có thể theo dõi những trạng
thái(status) của nhau.
Mơ hình mạng xã hội đơn giản
Mơ hình mạng xã hội tương đối đơn giản: những persons với tên và những status
được cập nhật dưới dạng văn bản text. Những thực thể được liên kết với nhau bằng
những mối quan hệ xác định.
Person:
• Friend: person và friend là hai người khác nhau
• Status: person liên kết với những status được cập nhật gần nhất
StatusUpdate:
• next: chỉ ra rằng những status kế tiếp trong chuỗi status, nó chỉ cái status
được post lên trước status hiện tại
HVTH: Nguyễn Xuân Nghề
Trang: 9
Xây dựng mạng xã hội với Neo4j
Thực thể status graph
Danh sách StatusUpdate cho một person là một danh sách liên kết. Đỉnh của danh sách
(những status gần đây nhất) được tìm thấy từ những status theo sau nó. Mỏi
StatusUpdate theo sau được liên kết bởi next.
Dưới đây là ví dụ với Andreas Kollegger làm việc tại buổi sang:
Để có thể đọc những status cập nhật, chúng ta có thể tạo một traversal như sau:
TraversalDescription traversal = Traversal.description(). depthFirst(). relationships( NEXT );
Luồng hoạt động
Khi chúng ta có bạn, và họ có những status, chúng ta có thể muốn đọc những status của
những người bạn chúng ta theo trình tự thời gian cái nào mới nhất trước. Thực hiện được
điều này qua những bước sau đây:
1.thu thập tất cả status của bạn và cập nhật vào một danh sách, status gần nhất lên đầu
2.sắp xếp danh sách
3.trả về phần tử đầu tiên của danh sách
4.nếu phần đầu tiên khơng có giá trị, xóa nó trong danh sách và lấy phần tử tiếp theo
5.trở lại bước 2 cho đến khi khơng cịn phần tử nào trong danh sách.
Code như sau:
PositionedIterator<StatusUpdate> first = statuses.get(0);
HVTH: Nguyễn Xuân Nghề
Trang: 10
Xây dựng mạng xã hội với Neo4j
StatusUpdate returnVal = first.current();
if ( !first.hasNext() )
{
statuses.remove( 0 );
}
else {
first.next();
sort();
}
return returnVal;
II.
Sử dụng Neo4j vào các ứng dụng java
Thật dễ dàng để thực hiện những ứng dụng Java với Neo4j . Trong phần này
chúng ta sẽ tìm thấy tất cả mọi thứ cần thiết cho việc viết một ứng dụng Java với Neo4j
1. Hello World
Trong phần này chúng ta sẽ tìm hiểu bằng cách nào để tạo và truy cập nodes và
các mối quan hệ. Với một đồ thị Neo4j chúng ta biết gồm những phần sau đây:
• Những nodes được liên kết lại với nhau
• Những mối quan hệ
• Thuộc tính của cả hai nodes và mối quan hệ
Tất cả mối quan hệ có một kiểu. Ví dụ, nếu đồ thị hiển thị một mạng xã hội, một
kiểu của mối quan hệ là KNOWS. Nếu có một mối quan hệ kiểu KNOWS liên kết
giữa 2 nodes, nó hiển thị rằng hai người này biết lẫn nhau.
a. Chuẩn bị database
Những kiểu mối quan hệ có thể được tạo bằng cách sử dụng một enum. Trong
ví dụ này chúng ta chỉ cần một kiểu mối quan hệ đơn giản:
private static enum RelTypes implements RelationshipType
{
HVTH: Nguyễn Xuân Nghề
Trang: 11
Xây dựng mạng xã hội với Neo4j
KNOWS
}
Chúng ta cũng chuẩn bị vài biến khác để sử dụng:
GraphDatabaseService graphDb;
Node firstNode;
Node secondNode;
Relationship relationship;
Bước tiếp theo là khởi động server dữ liệu.
graphDb = new GraphDatabaseFactory().n
registerShutdownHook( graphDb );
Như chúng ta thấy, chúng ta đăng ký một shutdown hook để chắc chắn rằng
database sẽ tắt khi JVM tắt để giải phóng server dữ liệu. và bây giơ chúng ta
bắt đầu tương tác với database.
b. Tạo một Small graph
Bây giờ, chúng ta bắt đầu tạo vài nodes, ở đây chúng ta tạo một đồ thị nhỏ với
2 nodes liên kết với một mối quan hệ và có vài thuộc tính:
firstNode = graphDb.createNode();
firstNode.setProperty( "message", "Hello, " );
secondNode = graphDb.createNode();
secondNode.setProperty( "message", "World!" );
relationship = firstNode.createRelationshipTo( secondNode,
relationship.setProperty( "message", "brave Neo4j " );
đồ thị của chúng ta giống như thế này:
HVTH: Nguyễn Xuân Nghề
Trang: 12
Xây dựng mạng xã hội với Neo4j
c. Hiển thị kết quả
sau khi chúng ta đã tạo đồ thị, chúng ta có thể đọc nó và in ra kết quả.
System.out.print( firstNode.getProperty( "message" ) );
System.out.print( relationship.getProperty( "message" ) );
System.out.print( secondNode.getProperty( "message" ) );
Kết quả sẽ là:
Hello, brave Neo4j World!
d. Xóa dữ liệu
Chúng ta tiến hành xóa dữ liệu như sau:
// let's remove the data
firstNode.getSingleRelationship( RelTypes.KNOWS, Direction.OUTGOING ).delete();
firstNode.delete();
secondNode.delete();
chú ý rằng việc xóa một node vẫn còn mối quan hệ sẽ bị báo lỗi. vì vậy cần xóa
mối quan hệ trước bởi vì một mối quan hệ tồn tại khi nó có node bắt đầu và node
kết thúc
e. Shut down server cơ sở dữ liệu
Cuối cùng, chúng ta shut down server cơ sở dữ liệu khi đã hoàn thành ứng dụng:
graphDb.shutdown();
IV.
V.
Sử dụng API REST từ Java
Tạo một đồ thị với REST API từ Java
REST API sử dụng HTTP và JSON, vì vậy nó có thể được sử dụng từ nhiều ngôn ngữ và
platforms. Trong phần này chúng ta sẽ tìm hiểu làm thế nào để tạo ra một đồ thị đơn giản
với REST API cũng như làm thế nào để truy vấn nó.
VI.
Khởi động server
Trước khi có thể thực hiện bất kỳ thao tác nào trên server, chúng ta cần khởi động nó
WebResource resource = Client.create().resource( SERVER_ROOT_URI );
HVTH: Nguyễn Xuân Nghề
Trang: 13
Xây dựng mạng xã hội với Neo4j
ClientResponse response = resource.get( ClientResponse.class );
System.out.println( String.format( "GET on [%s], status code [%d]",
SERVER_ROOT_URI, response.getStatus() ) );
response.close();
Nếu trạng thái response là 200 Ok, chúng ta biết rằng server đang chạy tốt và chúng ta có
thể tiếp tục
VII.
Tạo một node
REST API sử dụng POST để tạo những nodes. Ở đây chúng ta sử dụng jersey client làm
ví dụ:
final String nodeEntryPointUri = SERVER_ROOT_URI + "node";
// http://localhost:7474/db/data/node
WebResource resource = Client.create()
.resource( nodeEntryPointUri );
// POST {} to the node entry point URI
ClientResponse response = resource.accept( MediaType.APPLICATION_JSON )
.type( MediaType.APPLICATION_JSON )
.entity( "{}" )
.post( ClientResponse.class );
final URI location = response.getLocation();
System.out.println( String.format(
"POST to [%s], status code [%d], location header [%s]",
nodeEntryPointUri, response.getStatus(), location.toString() ) );
response.close();
return location;
Nếu q trình thực thi đoạn code trên thành cơng, nó sẽ gửi một u cầu HTTP chứa
thơng tin kiểu JSON đến server. Sau đó server sẽ tạo một node mới trong cơ sở dữ liệu và
trả lời lại là 201 Created.
HVTH: Nguyễn Xuân Nghề
Trang: 14
Xây dựng mạng xã hội với Neo4j
VIII.
Thêm thuộc tính
Khi chúng ta có nodes trong cơ sở dữ liệu, chúng ta có thể sử dụng chúng để lưu trữ
những dữ liệu có ích. Trong trường hợp này, chúng ta sẽ lưu thông tin và music vào
trong cơ sở dữ liệu chúng ta. Chúng ta tạo những nodes và thêm thuộc tính vào. Ở đây
chúng ta thêm những nodes hiển thị “Joe Strummer” và một ban nhạc gọi là “The Clash”.
URI firstNode = createNode();
addProperty( firstNode, "name", "Joe Strummer" );
URI secondNode = createNode();
addProperty( secondNode, "band", "The Clash" );
Trong phương thức addProperty chúng ta xác định nguồn mà sẽ hiển thị thuộc tính cho
node và xác định tên của thuộc tính đó. Sau đó chúng ta thực hiện tiến trình PUT những
giá trị của thuộc tính lên server.
String propertyUri = nodeUri.toString() + "/properties/" + propertyName;
// http://localhost:7474/db/data/node/{node_id}/properties/{property_name}
WebResource resource = Client.create()
.resource( propertyUri );
ClientResponse response = resource.accept( MediaType.APPLICATION_JSON )
.type( MediaType.APPLICATION_JSON )
.entity( "\"" + propertyValue + "\"" )
.put( ClientResponse.class );
System.out.println( String.format( "PUT to [%s], status code [%d]",
propertyUri, response.getStatus() ) );
response.close();
Nếu mọi thứ tiến triển tốt, chúng ta sẽ nhận 204 No Content back chỉ ra rằng server đã
xử lý yêu cầu nhưng không hiển thị lại giá trị thuộc tính.
HVTH: Nguyễn Xuân Nghề
Trang: 15
Xây dựng mạng xã hội với Neo4j
IX.
Thêm quan hệ
Bây giờ chúng ta có những nodes hiển thị Joe Strummer và The Class, chúng ta hãy
làm cho chúng có quan hệ với nhau.
URI relationshipUri = addRelationship( firstNode, secondNode, "singer",
"{ \"from\" : \"1976\", \"until\" : \"1986\" }" );
Trong phương thức addRelationship, chúng ta xác định URI về những mối quan hệ của
node Joe Strummer, sau đó POST một miêu tả JSON về mối quan hệ mà chúng ta cần
tạo. Miêu tả này chứa node đích đến, một nhãn cho kiểu mối quan hệ, và những thuộc
tính khác cho mối quan hệ.
private static URI addRelationship( URI startNode, URI endNode,
String relationshipType, String jsonAttributes )
throws URISyntaxException
{
URI fromUri = new URI( startNode.toString() + "/relationships" );
String relationshipJson = generateJsonRelationship( endNode, relationshipType, jsonAttributes );
WebResource resource = Client.create() .resource( fromUri );
// POST JSON to the relationships URI
ClientResponse response =
resource.accept( MediaType.APPLICATION_JSON ).type( MediaType.APPLICATION_JSON )
.entity( relationshipJson ).post( ClientResponse.class );
final URI location = response.getLocation();
System.out.println( String.format( "POST to [%s], status code [%d], location header [%s]", fromUri,
response.getStatus(), location.toString() ) );
response.close();
return location;
}
HVTH: Nguyễn Xuân Nghề
Trang: 16
Xây dựng mạng xã hội với Neo4j
X.
Thêm thuộc tính vào một quan hệ
Giống như nodes, quan hệ cũng có thể có những thuộc tính. Giả sử chúng ta là fans hâm
mộ của Joe Strummer và The Clash, chúng ta sẽ thêm vào một rating cho mối quan hệ
này vì vậy những người khác có thể thấy rằng Joe Strummer là một ca sĩ 5 sao trong ban
nhạc.
addMetadataToProperty( relationshipUri, "stars", "5" );
Trong phương thức addMetadataToProberty, chúng ta xác định URI của thuộc tính của
mối quan hệ và PUT giá trị mới vào (PUT sẽ ghi đè lên những giá trị đã tồn tại, hãy cẩn
thận điều này).
private static void addMetadataToProperty( URI relationshipUri,
String name, String value ) throws URISyntaxException
{
URI propertyUri = new URI( relationshipUri.toString() + "/properties" );
String entity = toJsonNameValuePairCollection( name, value );
WebResource resource = Client.create()
.resource( propertyUri );
ClientResponse response = resource.accept( MediaType.APPLICATION_JSON )
.type( MediaType.APPLICATION_JSON )
.entity( entity )
.put( ClientResponse.class );
System.out.println( String.format(
"PUT [%s] to [%s], status code [%d]", entity, propertyUri,
response.getStatus() ) );
response.close();
}
Giả sữ tất cả đều tiến triển tốt, chúng ta sẽ nhận trả lời lại 200 Ok từ server
XI.
Truy vấn đồ thị
Neo4j server sử dụng duyệt đồ thị(graph traversals) để tìm kiếm dữ liệu trong đồ thị.
Hiện tại Neo4j server sử dụng một mơ tả JSON để thực hiện q trình duyệt đồ thị này.
HVTH: Nguyễn Xuân Nghề
Trang: 17
Xây dựng mạng xã hội với Neo4j
Để bắt đầu quá trình, chúng ta sử dụng một lớp đơn giản có thể chuyển những thông tin
của đồ thị sang dạng dữ liệu JSON tương ứng, sẳng sàng cho việc POST-ing lên server.
Trong trường hợp này chúng ta phải lập trình(hardcode) để tìm tất cả những nodes với có
mối quan hệ với kiểu “singer”
// TraversalDescription turns into JSON to send to the Server
TraversalDescription t = new TraversalDescription();
t.setOrder( TraversalDescription.DEPTH_FIRST );
t.setUniqueness( TraversalDescription.NODE );
t.setMaxDepth( 10 );
t.setReturnFilter( TraversalDescription.ALL );
t.setRelationships( new Relationship( "singer", Relationship.OUT ) );
khi chúng ta đã định nghĩa những tham số của quá trình tìm kiếm, chúng ta chỉ cần
transfer chúng. Chúng ta làm điều này bằng cách xác định URI của quá trình tìm kiếm
cho node bắt đầu, và sau đó POST-ing dạng hiển thị JSON của nó.
URI traverserUri = new URI( startNode.toString() + "/traverse/node" );
WebResource resource = Client.create()
.resource( traverserUri );
String jsonTraverserPayload = t.toJson();
ClientResponse response = resource.accept( MediaType.APPLICATION_JSON )
.type( MediaType.APPLICATION_JSON )
.entity( jsonTraverserPayload )
.post( ClientResponse.class );
System.out.println( String.format(
"POST [%s] to [%s], status code [%d], returned data: "
+ System.getProperty( "line.separator" ) + "%s",
jsonTraverserPayload, traverserUri, response.getStatus(),
response.getEntity( String.class ) ) );
response.close();
HVTH: Nguyễn Xuân Nghề
Trang: 18
Xây dựng mạng xã hội với Neo4j
khi yêu cầu của chúng ta được thực hiện, chúng ta nhận về dữ liệu về singer và bans
theo yêu đúng yêu cầu.
[{
"outgoing_relationships" : "http://localhost:7474/db/data/node/82/relationships/out",
"data" : {
"band" : "The Clash",
"name" : "Joe Strummer"
},
"traverse" : "http://localhost:7474/db/data/node/82/traverse/{returnType}",
"all_typed_relationships" : "http://localhost:7474/db/data/node/82/relationships/all/{-list|&|types}"
"property" : "http://localhost:7474/db/data/node/82/properties/{key}",
"all_relationships" : "http://localhost:7474/db/data/node/82/relationships/all",
"self" : "http://localhost:7474/db/data/node/82",
"properties" : "http://localhost:7474/db/data/node/82/properties",
"outgoing_typed_relationships" : "http://localhost:7474/db/data/node/82/relationships/out/{-list|&|ty
"incoming_relationships" : "http://localhost:7474/db/data/node/82/relationships/in",
"incoming_typed_relationships" : "http://localhost:7474/db/data/node/82/relationships/in/{-list|&|typ
"create_relationship" : "http://localhost:7474/db/data/node/82/relationships"
}, {
"outgoing_relationships" : "http://localhost:7474/db/data/node/83/relationships/out",
"data" : {
},
"traverse" : "http://localhost:7474/db/data/node/83/traverse/{returnType}",
"all_typed_relationships" : "http://localhost:7474/db/data/node/83/relationships/all/{-list|&|types}"
"property" : "http://localhost:7474/db/data/node/83/properties/{key}",
"all_relationships" : "http://localhost:7474/db/data/node/83/relationships/all",
"self" : "http://localhost:7474/db/data/node/83",
"properties" : "http://localhost:7474/db/data/node/83/properties",
"outgoing_typed_relationships" : "http://localhost:7474/db/data/node/83/relationships/out/{-list|&|ty
"incoming_relationships" : "http://localhost:7474/db/data/node/83/relationships/in",
"incoming_typed_relationships" : "http://localhost:7474/db/data/node/83/relationships/in/{-list|&|typ
"create_relationship" : "http://localhost:7474/db/data/node/83/relationships"
}]
HVTH: Nguyễn Xuân Nghề
Trang: 19
Xây dựng mạng xã hội với Neo4j
XII.
Framework duyệt đồ thị Java API
1. Nội dung chính
Dưới đây là một giải thích ngắn về những phương thức khác nhau có thể sửa đổi và thêm
vào việc mơ tả q trình duyệt đồ thị
Expanders: định nghĩa những gì muốn duyệt, tiêu biểu là dựa theo hướng và kiểu mối
quan hệ.
Order: ví dụ như duyệt theo chiều sâu hoặc duyệt theo chiều rộng
Uniqueness: ghé thăm nodes(mối quan hệ, đường dẫn) chỉ một duy nhất
Evaluator: quyết định cái gì cần trả về, khi nào dừng hoặc tiếp tục duyệt đồ thị tại vị trí
node hiện tại
Starting nodes:node mà quá trình duyệt sẽ bắt đầu.
2. Framework duyệt đồ thị Java API
Framework duyệt đồ thị chứa đựng những giao diện (interfaces) chính trong
việc xử lý với nodes và mối quan hệ: TraversalDescription, Evaluator,
HVTH: Nguyễn Xuân Nghề
Trang: 20
Xây dựng mạng xã hội với Neo4j
Traverser và Uniqueness là những phần chính. Giao diện path cũng có mục
đích đặt biệt trong việc duyệt đồ thị, nó dùng để hiển thị một vị trí trong đồ thị
khi đã thực hiện việc tính tốn đối với vị trí này. Hơn nữa giao diện
PathExpander và Expander là trung tâm của quá trình duyệt đồ thị, nhưng
người dùng ít cài đặt chúng.
a. TraversalDescription
TravesalDescription là giao diện chính được dùng trong việc định nghĩa
và khởi tạo quá trình duyệt đồ thị.
Thực thể TraversalDescription là khơng thay đổi và những phương thức của
nó trả về một đối tượng new TraversalDescription.
Quan hệ (Relationships)
Thêm một kiểu quan hệ vào một danh sách những kiểu quan hệ để duyệt đồ
thị. Theo mặc định danh sách này là rỗng và nó có nghĩa là nó sẽ duyệt tất
cả các quan hệ không trừ kiểu nào. Nếu một hoặc nhiều quan hệ được thêm
vào danh sách thì chỉ những kiểu quan hệ sẽ được duyệt. Có hai phương
thức, một là including direction và excluding direction
b. Đánh giá (Evaluator)
Evaluator được sử dụng cho việc quyết định, tại mỏi vị trí(hiển thị trên đồ
thị) sẽ được duyệt tiếp hay thêm node tại vị trí này vào kết quả. Chúng ta có
một trong bốn hành động sau đây của quá trình duyệt động thị.
Evaluation.INCLUDE_AND_CONTINUE: Thêm node này vào danh sách
kết quả và tiếp tục duyệt
Evaluation.INCLUDE_AND_PRUNE: Thêm node này vào danh sách kết
quả và không duyệt nữa.
Evaluation.EXCLUDE_AND_CONTINUE: Không thêm node này vào
danh sách kết quả và tiếp tục duyệt.
HVTH: Nguyễn Xuân Nghề
Trang: 21
Xây dựng mạng xã hội với Neo4j
Evaluation. EXCLUDE _AND_ PRUNE: Không thêm node này vào danh
sách kết quả và không duyệt nữa.
c. Duy nhất (Uniqueness)
Tập hợp những luật cho việc những vị trí có thể được duyệt lại trong suốt quá trình
duyệt đồ thị được quy định trong Uniqueness. Mặt định là NODE_GLOBAL
Có rất nhiều uniqueness được sử dụng trong Neo4j:
• NONE: bất kỳ vị trí nào trong đồ thị có thể được duyệt lại
• NOD_GLAOBAL uniqueness: khơng node nào trong đồ thị có thể được
duyệt hơn một lần.
• RELATIONSHIP_GLOBAL uniqueness: không quan hệ nào trong đồ thị
được duyệt hơn một lần
• NODE_PATH uniqueness: một node khơng xuất hiện nếu một đường dẫn
trước đây có node này.
• …
d. Sử dụng Framework duyệt đồ thị
HVTH: Nguyễn Xuân Nghề
Trang: 22
Xây dựng mạng xã hội với Neo4j
Việc định nghĩa RelationshipTypes như sau:
private enum Rels implements RelationshipType
{
LIKES, KNOWS
}
Đồ thị có thể được duyệt với đồ thị trên, bắt đầu từ node “Joe”
for ( Path position : Traversal.description().depthFirst().relationships( Rels.KNOWS )
.relationships( Rels.LIKES, Direction.INCOMING )
.evaluator( Evaluators.toDepth( 5 ) )
.traverse( node ) )
{
output += position + "\n";
HVTH: Nguyễn Xuân Nghề
Trang: 23
Xây dựng mạng xã hội với Neo4j
}
Kết quả hiển thị:
(7)
(7)<--[LIKES,1]--(4)
(7)<--[LIKES,1]--(4)--[KNOWS,6]-->(1)
(7)<--[LIKES,1]--(4)--[KNOWS,6]-->(1)--[KNOWS,4]-->(6)
(7)<--[LIKES,1]--(4)--[KNOWS,6]-->(1)--[KNOWS,4]-->(6)--[KNOWS,3]-->(5)
(7)<--[LIKES,1]--(4)--[KNOWS,6]-->(1)--[KNOWS,4]-->(6)--[KNOWS,3]-->(5)--[KNOWS,2]->(2)
(7)<--[LIKES,1]--(4)--[KNOWS,6]-->(1)<--[KNOWS,5]--(3)
XIII.
Giải thuật đồ thị
Giải thuật đồ thị Neo4j là một thành phần chứa một vài giải thuật chung cho đồ thị. Nó
bao gồm những giải thuật như sau:
• Đường đi ngắn nhất
• Tất cả đường đi
• Tất cả đường đi đơn giản
• Dijkstra
• *A
XIV.
Ví dụ về giải thuật đồ thị
Tính đường đi ngắn nhất (ít số lượng quan hệ nhất) giữa 2 nodes:
Node startNode = graphDb.createNode();
Node middleNode1 = graphDb.createNode();
Node middleNode2 = graphDb.createNode();
Node middleNode3 = graphDb.createNode();
Node endNode = graphDb.createNode();
createRelationshipsBetween( startNode, middleNode1, endNode );
createRelationshipsBetween( startNode, middleNode2, middleNode3, endNode );
HVTH: Nguyễn Xuân Nghề
Trang: 24
Xây dựng mạng xã hội với Neo4j
// Will find the shortest path between startNode and endNode via
// "MY_TYPE" relationships (in OUTGOING direction), like f.ex:
//
// (startNode)-->(middleNode1)-->(endNode)
//
PathFinder<Path> finder = GraphAlgoFactory.shortestPath(
Traversal.expanderForTypes( ExampleTypes.MY_TYPE, Direction.OUTGOING ), 15 );
Iterable<Path> paths = finder.findAllPaths( startNode, endNode );
Sử dụng giải thuật Dijkstra để tính tốn đường đi ngắn nhất giữa node A và B và mỗi
quan hệ có một trọng số và đường đi ngắn nhất được tìm thấy.
PathFinder<WeightedPath> finder = GraphAlgoFactory.dijkstra(
Traversal.expanderForTypes( ExampleTypes.MY_TYPE, Direction.BOTH ), "cost" );
WeightedPath path = finder.findSinglePath( nodeA, nodeB );
// Get the weight for the found path
path.weight();
Sử dụng A* để tính đường đi ngắn nhất giữa node A và node B, đường đi ngắn nhất ví dụ
như đường đi của những đoạn đường và có chiều dài ngắn nhất giữa node A và node B.
Dưới đây là ví dụ về đồ thị:
Node nodeA = createNode( "name", "A", "x", 0d, "y", 0d );
Node nodeB = createNode( "name", "B", "x", 7d, "y", 0d );
Node nodeC = createNode( "name", "C", "x", 2d, "y", 1d );
Relationship relAB = createRelationship( nodeA, nodeC, "length", 2d );
HVTH: Nguyễn Xuân Nghề
Trang: 25
