(三)play之yabe项目【数据模型】

(三)play之yabe项目【数据模型】

博客分类：

• 框架@play framework

 

创建项目

play new yabe

What is the application name? [yabe] Blog Engine

play eclipsify yabe

play run yabe

Eclipse引入项目

file -> import -> General ->Existing Projects into Workspaces -> select root directory ...

设置数据库

选择一个内存数据库

打开yabe/conf/application.conf，去掉下面这行的注释

db=mem #使用内存数据库，使用HSQL

【hsql 数据库是一款纯Java编写的免费数据库，体积小，才563kb。仅一个hsqldb.jar文件就包括了数据库引擎，数据库驱动，还有其他用户界面操作等内容。纯Java设计，又支持 SQL99，SQL2003大部分的标准】

************************************************************************************************************

增加模型User

1. package models;
2. import javax.persistence.Entity;
3. import play.db.jpa.Model;
4. @Entity
5. public class User extends Model {
6. public String email;
7. public String password;
8. public String fullname;
9. public boolean isAdmin;
10. public User(String email,String password, String fullname) {
11. this.email = email;
12. this.password = password;
13. this.fullname = fullname;
14. }
15. }

使用JUNIT进行单元测试

打开命令行，切换到测试模式

play  test yabe

play提供了默认的测试文件，打开yabe\test\BasicTest.java

删除aVeryImportantThingToTest，新建一个测试

1. import org.junit.*;
2. import java.util.*;
3. import play.test.*;
4. import models.*;
5. /**
6. * 测试单元 extends UnitTest
7. * @author lenovo
8. *
9. */
10. public class BasicTest extends UnitTest {
11. @Test
12. public void createAndRetriveUser() {
13. //Create a User and save
14. new User("[e-mail]","******","ZS").save();
15. //retrieve User by emial
16. User user1 = User.find("email", "[e-mail]").first();
17. //两种写法都可以 匹配email="[e-mail]"的User对象
18. User user2 = User.find("byEmail", "[e-mail]").first();
19. assertNotNull(user1);
20. assertNotNull(user2);
21. assertEquals(user1, user2);
22. assertEquals("ZS", user1.fullname);
23. assertEquals("ZS", user2.fullname);
24. }
25. }

打开http://localhost:9000/@tests

运行BasicTest，即上面写的测试单元，点击Start !   进行测试

结果应该为绿色！

接下来测试User的email和password是否正确的方法

通过email和password两个条件来找到User对象

打开User.java，添加connect()：

1. package models;
2. import javax.persistence.Entity;
3. import play.db.jpa.Model;
4. @Entity
5. public class User extends Model {
6. public String email;
7. public String password;
8. public String fullname;
9. public boolean isAdmin;
10. public User(String email,String password, String fullname) {
11. this.email = email;
12. this.password = password;
13. this.fullname = fullname;
14. }
15. /**
16. * 联合email和password两个条件查询User
17. * @param email
18. * @param password
19. * @return
20. */
21. public static User connect(String email, String password) {
22. return find("byEmailAndPassword", email, password).first();
23. }
24. }

在BasicTest.java里添加测试方法

1. import org.junit.*;
2. import java.util.*;
3. import play.test.*;
4. import models.*;
5. /**
6. * 测试单元 extends UnitTest
7. * @author lenovo
8. *
9. */
10. public class BasicTest extends UnitTest {
11. /**
12. * 测试用户的创建和查找
13. */
14. @Test
15. public void createAndRetriveUser() {
16. //Create a User and save
17. new User("[e-mail]","******","ZS").save();
18. //retrieve User by emial
19. User user1 = User.find("email", "[e-mail]").first();
20. //两种写法都可以 匹配email="[e-mail]"的User对象
21. User user2 = User.find("byEmail", "[e-mail]").first();
22. assertNotNull(user1);
23. assertNotNull(user2);
24. assertEquals(user1, user2);
25. assertEquals("ZS", user1.fullname);
26. assertEquals("ZS", user2.fullname);
27. }
28. /**
29. * 测试联合条件查询
30. */
31. @Test
32. public void tryConnectUser() {
33. //Create a user and save it
34. new User("[e-mail]", "123", "zhangsan").save();
35. //Test
36. assertNotNull(User.connect("[e-mail]", "123"));
37. assertNull(User.connect("[e-mail]", "234"));
38. assertNull(User.connect("[e-mail]", "234"));
39. }
40. }

http://localhost:9000/@tests

测试BasicTest项，应该全部通过！

增加模型Post

Post类作为博客的实体类，与User之间为多对一的关系

1. package models;
2. import java.util.Date;
3. import javax.persistence.Entity;
4. import javax.persistence.Lob;
5. import javax.persistence.ManyToOne;
6. import play.db.jpa.Model;
7. @Entity
8. public class Post extends Model {
9. public String title;
10. public Date postedAt;
11. //@Lob标注：声明这是一个超大文本数据类型，用于存储发布的博客内容
12. @Lob
13. public String content;
14. //@ManyToOne：声明Post与User之间是多对一的关系
15. //一个用户可以发布多个博客，一个博客只能被一个用户所发布
16. @ManyToOne
17. public User author;
18. public Post(String title, String content, User author) {
19. this.title = title;
20. this.content = content;
21. this.author = author;
22. this.postedAt = new Date();
23. }
24. }

对Post类进行测试

1. import org.junit.*;
2. import java.util.*;
3. import play.test.*;
4. import models.*;
5. /**
6. * 测试单元 extends UnitTest
7. * @author lenovo
8. *
9. */
10. public class BasicTest extends UnitTest {
11. /**
12. * 清空数据库中的数据，释放内存空间
13. * Fixtures帮助在测试期间管理数据库
14. */
15. @Before
16. public void setup() {
17. Fixtures.deleteDatabase();
18. }
19. /**
20. * 测试用户的创建和查找
21. */
22. @Test
23. public void createAndRetriveUser() {
24. //Create a User and save
25. new User("[e-mail]","******","ZS").save();
26. //retrieve User by emial
27. User user1 = User.find("email", "[e-mail]").first();
28. //两种写法都可以 匹配email="[e-mail]"的User对象
29. User user2 = User.find("byEmail", "[e-mail]").first();
30. assertNotNull(user1);
31. assertNotNull(user2);
32. assertEquals(user1, user2);
33. assertEquals("ZS", user1.fullname);
34. assertEquals("ZS", user2.fullname);
35. }
36. /**
37. * 测试联合条件查询
38. */
39. @Test
40. public void tryConnectUser() {
41. //Create a user and save it
42. new User("[e-mail]", "123", "zhangsan").save();
43. //Test
44. assertNotNull(User.connect("[e-mail]", "123"));
45. assertNull(User.connect("[e-mail]", "234"));
46. assertNull(User.connect("[e-mail]", "234"));
47. }
48. /**
49. * 测试Post类
50. */
51. @Test
52. public void createPost() {
53. //Create a User and save it
54. User Mike = new User("[e-mail]", "111", "Mike").save();
55. //Create 2 Post
56. new Post("First Blog", "first", Mike).save();
57. new Post("Second Blog", "second", Mike).save();
58. //测试是否成功创建了2个Post对象
59. assertEquals(2, Post.count());
60. //获取lisi发布的所有博客
61. List<Post> posts = Post.find("byAuthor", Mike).fetch();
62. assertEquals(2, posts.size());
63. assertNotNull(posts.get(0));
64. assertNotNull(posts.get(1));
65. assertEquals(Mike, posts.get(0).author);
66. assertEquals("First Blog", posts.get(0).title);
67. assertEquals("second", posts.get(1).content);
68. assertNotNull(posts.get(1).postedAt);
69. }
70. }

增加模型Comment

Comment 与 Post 之间为多对一的关系，多条评论对应一篇博客

1. package models;
2. import java.util.Date;
3. import javax.persistence.Entity;
4. import javax.persistence.Lob;
5. import javax.persistence.ManyToOne;
6. import play.db.jpa.Model;
7. @Entity
8. public class Comment extends Model {
9. public String author;
10. public Date postedAt;
11. @Lob
12. public String content;
13. //一篇博客对应多条评论，一个评论属于一篇博客
14. //评论与博客的关系：多对一
15. @ManyToOne
16. public Post post;
17. public Comment(String author, String content, Post post) {
18. super();
19. this.author = author;
20. this.content = content;
21. this.post = post;
22. this.postedAt = new Date();
23. }
24. }

修改模型Post，增加Comment属性

注：上面的User类也可以持有一个关于Post的集合，方法与此类似。

1. package models;
2. import java.util.ArrayList;
3. import java.util.Date;
4. import java.util.List;
5. import javax.persistence.CascadeType;
6. import javax.persistence.Entity;
7. import javax.persistence.Lob;
8. import javax.persistence.ManyToOne;
9. import javax.persistence.OneToMany;
10. import play.db.jpa.Model;
11. @Entity
12. public class Post extends Model {
13. public String title;
14. public Date postedAt;
15. //@Lob标注：声明这是一个超大文本数据类型，用于存储发布的博客内容
16. @Lob
17. public String content;
18. //@ManyToOne：声明Post与User之间是多对一的关系
19. //一个用户可以发布多个博客，一个博客只能被一个用户所发布
20. @ManyToOne
21. public User author;
22. //1篇博客对应多个评论
23. //删除某篇博客，则级联删除其评论
24. @OneToMany(mappedBy="post", cascade=CascadeType.ALL)
25. public List<Comment> comments;
26. public Post(String title, String content, User author) {
27. this.comments = new ArrayList<Comment>(0);
28. this.title = title;
29. this.content = content;
30. this.author = author;
31. this.postedAt = new Date();
32. }
33. /**
34. * 在Post中实现评论的添加保存操作
35. * 同时更新Post所持有的Comment的集合！
36. */
37. public Post addComment(String author, String content) {
38. //保存对方
39. Comment newComment = new Comment(author, content, this).save();
40. //把对方加入到自己管理的集合中
41. this.comments.add(newComment);
42. //同步到数据库
43. this.save();
44. return this;
45. }
46. }

所有的测试代码

1. import org.junit.*;
2. import java.util.*;
3. import play.test.*;
4. import models.*;
5. /**
6. * 测试单元 extends UnitTest
7. * @author lenovo
8. *
9. */
10. public class BasicTest extends UnitTest {
11. /**
12. * 清空数据库中的数据，释放内存空间
13. * Fixtures帮助在测试期间管理数据库
14. */
15. @Before
16. public void setup() {
17. Fixtures.deleteDatabase();
18. }
19. /**
20. * 测试用户的创建和查找
21. */
22. @Test
23. public void createAndRetriveUser() {
24. //Create a User and save
25. new User("[e-mail]","******","ZS").save();
26. //retrieve User by emial
27. User user1 = User.find("email", "[e-mail]").first();
28. //两种写法都可以 匹配email="[e-mail]"的User对象
29. User user2 = User.find("byEmail", "[e-mail]").first();
30. assertNotNull(user1);
31. assertNotNull(user2);
32. assertEquals(user1, user2);
33. assertEquals("ZS", user1.fullname);
34. assertEquals("ZS", user2.fullname);
35. }
36. /**
37. * 测试联合条件查询
38. */
39. @Test
40. public void tryConnectUser() {
41. //Create a user and save it
42. new User("[e-mail]", "123", "zhangsan").save();
43. //Test
44. assertNotNull(User.connect("[e-mail]", "123"));
45. assertNull(User.connect("[e-mail]", "234"));
46. assertNull(User.connect("[e-mail]", "234"));
47. }
48. /**
49. * 测试Post类
50. */
51. @Test
52. public void createPost() {
53. //Create a User and save it
54. User Mike = new User("[e-mail]", "111", "Mike").save();
55. //Create 2 Post
56. new Post("First Blog", "first", Mike).save();
57. new Post("Second Blog", "second", Mike).save();
58. //测试是否成功创建了2个Post对象
59. assertEquals(2, Post.count());
60. //获取lisi发布的所有博客
61. List<Post> posts = Post.find("byAuthor", Mike).fetch();
62. assertEquals(2, posts.size());
63. assertNotNull(posts.get(0));
64. assertNotNull(posts.get(1));
65. assertEquals(Mike, posts.get(0).author);
66. assertEquals("First Blog", posts.get(0).title);
67. assertEquals("second", posts.get(1).content);
68. assertNotNull(posts.get(1).postedAt);
69. }
70. /**
71. * 测试Post与User的多对一关系
72. */
73. @Test
74. public void testPost2User() {
75. User Mike = new User("[e-mail]", "111", "Mike").save();
76. Mike.addPost("First Blog", "first");
77. Mike.addPost("Second Blog", "second");
78. assertNotNull(Mike);
79. assertEquals(2, Post.count());
80. //从新查询User
81. Mike = User.connect("[e-mail]", "111");
82. //直接从User中获取Post的集合
83. assertEquals(2, Mike.posts.size());
84. assertEquals("first", Mike.posts.get(0).content);
85. assertEquals("second", Mike.posts.get(1).content);
86. }
87. /**
88. * 测试Comment类
89. * 单向，由Comment得到Post
90. */
91. @Test
92. public void testComment() {
93. User Mike = new User("[e-mail]", "111", "Mike").save();
94. Post post = new Post("First Blog", "first", Mike).save();
95. new Comment("jeff", "nice post", post).save();
96. new Comment("henrry", "good post", post).save();
97. //获取博客的所有评论
98. List<Comment> comments = Comment.find("byPost", post).fetch();
99. assertEquals(2, comments.size());
100. Comment firstComment = comments.get(0);
101. assertNotNull(firstComment);
102. assertEquals("jeff", firstComment.author);
103. assertEquals("nice post", firstComment.content);
104. assertNotNull(firstComment.postedAt);
105. Comment secondComment = comments.get(1);
106. assertNotNull(secondComment);
107. assertEquals("henrry", secondComment.author);
108. assertEquals("good post", secondComment.content);
109. assertNotNull(firstComment.postedAt);
110. }
111. /**
112. * 测试Comment与Post的多对一关系
113. * 双向，由Post直接得到与此关联的Comment集合
114. */
115. @Test
116. public void testComment2PostRelation() {
117. //User
118. User bob = new User("[e-mail]","111","Bob well").save();
119. //Post
120. Post post = new Post("First post","hello kelly",bob).save();
121. //Comment
122. post.addComment("jeff", "Nice Post!");
123. post.addComment("Tom", "I knew that!");
124. assertEquals(1, User.count());
125. assertEquals(1, Post.count());
126. assertEquals(2, Comment.count());
127. //Retrieve Bob's post
128. post = Post.find("byAuthor", bob).first();
129. assertNotNull(post);
130. //Navigation to comments
131. assertEquals(2, post.comments.size());
132. assertEquals("jeff", post.comments.get(0).author);
133. //delete Post
134. post.delete();
135. //check that all commonts have been deleted
136. assertEquals(1, User.count());
137. assertEquals(0, Post.count());
138. assertEquals(0, Comment.count());
139. }
140. }