This is a part of an online Codename One course published around 2017 see it all for free at https://debugagent.com/series/cn1

1. Creating a Facebook Clone - Part XXXI
The next big step is making this into a "real" app by implementing a lot of the "details" such as comments, search & settings. Each one of these seems like a huge task
but surprisingly they aren't as hard as one would have expected!

2. <scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.mashape.unirest</groupId>
<artifactId>unirest-java</artifactId>
<version>1.4.9</version>
</dependency>
<dependency>
<groupId>com.twilio.sdk</groupId>
<artifactId>twilio</artifactId>
<version>7.17.0</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-search-orm</artifactId>
<version>5.8.2.Final</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
pom.xml
For search we need to leap back into the server code to implement search. On the surface search seems like a complex problem but thankfully Spring Boot & hibernate
magically solve that for us!
Hibernate is the default JPA implementation in Spring Boot. One of its features is integration with Lucene/Elastic Search which you can read about at hibernate.org/
search/.
Spring Boot makes that even simpler. We can support search by making a small change to the pom.xml file.

3. spring.datasource.url=jdbc:mysql://localhost/facebookclone
spring.datasource.username=root
spring.datasource.password=XXXXXXXX
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.generate-ddl=true
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.http.multipart.max-file-size=100MB
spring.http.multipart.max-request-size=100MB
spring.servlet.multipart.maxFileSize=100MB
spring.servlet.multipart.maxRequestSize=100MB
spring.jackson.default-property-inclusion=non_null
hibernate.search.default.directory_provider = filesystem
hibernate.search.default.indexBase = /data/index/default
application.properties
Then we need to configure search in the application.properties file as such…
These just mean the search index is saved into the file system which is the simplest approach for implementing this. There is a lot of power behind this tool and you can
learn more about it in their website.

4. @Entity
@Indexed
public class User {
@Id
private String id;
@Field
private String firstName;
@Field
private String familyName;
@Column(unique=true)
private String email;
@Column(unique=true)
private String phone;
private String gender;
private String verificationCode;
private String verifiedEmailAddress;
User (Entity)
Users can't search everything, that would be bad as we don't want the ability to search through passwords etc.
We can add search support by marking an Entity with the @Indexed annotation then marking each field that should be indexed with the @Field annotation.
Notice that we should use the org.hibernate.search.annotations package for these annotations as there is another Indexed class in Spring Boot

5. @Entity
@Indexed
public class User {
@Id
private String id;
@Field
private String firstName;
@Field
private String familyName;
@Column(unique=true)
private String email;
@Column(unique=true)
private String phone;
private String gender;
private String verificationCode;
private String verifiedEmailAddress;
User (Entity)
We only index the name of the user as we don't necessarily want to expose private data through search

6. @Entity
@Indexed
public class Post {
@Id
private String id;
@ManyToOne
private User user;
private long date;
@Field
private String title;
@Field
private String content;
private String visibility;
private String styling;
@OneToMany
@OrderBy("date ASC")
private Set<Comment> comments;
Post (Entity)
We'll do a similar change to Post which contains fields worth indexing. We only index the text content as other content might produce weird results in search.
I could go further with searching comments etc. but for simplicity I stopped here.

7. @Service
public class SearchService {
@Autowired
private EntityManager manager;
private FullTextEntityManager ft() {
return Search.getFullTextEntityManager(manager);
}
public void rebuildSearchDB() {
ft().createIndexer().start();
}
private <T> List<T> genericSearch(String text, int page, int amount,
Class type, String... fields) {
FullTextEntityManager ft = ft();
QueryBuilder queryBuilder = ft.getSearchFactory()
.buildQueryBuilder()
.forEntity(type).get();
Query query = queryBuilder.keyword().fuzzy()
SearchService
With that the entities should be completely searchable. We now need to expose the search functionality in the service layer.
This warrants a brand new SearchService class.

8. @Service
public class SearchService {
@Autowired
private EntityManager manager;
private FullTextEntityManager ft() {
return Search.getFullTextEntityManager(manager);
}
public void rebuildSearchDB() {
ft().createIndexer().start();
}
private <T> List<T> genericSearch(String text, int page, int amount,
Class type, String... fields) {
FullTextEntityManager ft = ft();
QueryBuilder queryBuilder = ft.getSearchFactory()
.buildQueryBuilder()
.forEntity(type).get();
Query query = queryBuilder.keyword().fuzzy()
SearchService
The entity manager provides direct access to the underlying JPA implementation. Normally Spring Boot hides that but for search we need direct access

9. @Service
public class SearchService {
@Autowired
private EntityManager manager;
private FullTextEntityManager ft() {
return Search.getFullTextEntityManager(manager);
}
public void rebuildSearchDB() {
ft().createIndexer().start();
}
private <T> List<T> genericSearch(String text, int page, int amount,
Class type, String... fields) {
FullTextEntityManager ft = ft();
QueryBuilder queryBuilder = ft.getSearchFactory()
.buildQueryBuilder()
.forEntity(type).get();
Query query = queryBuilder.keyword().fuzzy()
SearchService
This is a small helper method that shortens the boilerplate syntax to ft() instead all of that code…

10. @Service
public class SearchService {
@Autowired
private EntityManager manager;
private FullTextEntityManager ft() {
return Search.getFullTextEntityManager(manager);
}
public void rebuildSearchDB() {
ft().createIndexer().start();
}
private <T> List<T> genericSearch(String text, int page, int amount,
Class type, String... fields) {
FullTextEntityManager ft = ft();
QueryBuilder queryBuilder = ft.getSearchFactory()
.buildQueryBuilder()
.forEntity(type).get();
Query query = queryBuilder.keyword().fuzzy()
SearchService
We first need to build a search database, this is a one time operation. Once the database is built Hibernate will keep the database up to date

11. }
public void rebuildSearchDB() {
ft().createIndexer().start();
}
private <T> List<T> genericSearch(String text, int page, int amount,
Class type, String... fields) {
FullTextEntityManager ft = ft();
QueryBuilder queryBuilder = ft.getSearchFactory()
.buildQueryBuilder()
.forEntity(type).get();
Query query = queryBuilder.keyword().fuzzy()
.onFields(fields).matching(text).createQuery();
FullTextQuery jpaQuery = ft.createFullTextQuery(query, type);
return jpaQuery.setFirstResult(page * amount).
setMaxResults(amount).getResultList();
}
public List<UserDAO> searchPeople(String name, int page, int amount) {
List<User> results = genericSearch(name, page, amount,
User.class, "firstName", "familyName");
SearchService
We have two types of searches so I combined their common logic into this method

12. }
public void rebuildSearchDB() {
ft().createIndexer().start();
}
private <T> List<T> genericSearch(String text, int page, int amount,
Class type, String... fields) {
FullTextEntityManager ft = ft();
QueryBuilder queryBuilder = ft.getSearchFactory()
.buildQueryBuilder()
.forEntity(type).get();
Query query = queryBuilder.keyword().fuzzy()
.onFields(fields).matching(text).createQuery();
FullTextQuery jpaQuery = ft.createFullTextQuery(query, type);
return jpaQuery.setFirstResult(page * amount).
setMaxResults(amount).getResultList();
}
public List<UserDAO> searchPeople(String name, int page, int amount) {
List<User> results = genericSearch(name, page, amount,
User.class, "firstName", "familyName");
SearchService
The query builder searches a specific entity e.g. Post, User etc. once we have it we can construct a complex search query

13. }
public void rebuildSearchDB() {
ft().createIndexer().start();
}
private <T> List<T> genericSearch(String text, int page, int amount,
Class type, String... fields) {
FullTextEntityManager ft = ft();
QueryBuilder queryBuilder = ft.getSearchFactory()
.buildQueryBuilder()
.forEntity(type).get();
Query query = queryBuilder.keyword().fuzzy()
.onFields(fields).matching(text).createQuery();
FullTextQuery jpaQuery = ft.createFullTextQuery(query, type);
return jpaQuery.setFirstResult(page * amount).
setMaxResults(amount).getResultList();
}
public List<UserDAO> searchPeople(String name, int page, int amount) {
List<User> results = genericSearch(name, page, amount,
User.class, "firstName", "familyName");
SearchService
The search for keywords is marked as fuzzy which means it will find answers that don't match completely for the given text

14. }
public void rebuildSearchDB() {
ft().createIndexer().start();
}
private <T> List<T> genericSearch(String text, int page, int amount,
Class type, String... fields) {
FullTextEntityManager ft = ft();
QueryBuilder queryBuilder = ft.getSearchFactory()
.buildQueryBuilder()
.forEntity(type).get();
Query query = queryBuilder.keyword().fuzzy()
.onFields(fields).matching(text).createQuery();
FullTextQuery jpaQuery = ft.createFullTextQuery(query, type);
return jpaQuery.setFirstResult(page * amount).
setMaxResults(amount).getResultList();
}
public List<UserDAO> searchPeople(String name, int page, int amount) {
List<User> results = genericSearch(name, page, amount,
User.class, "firstName", "familyName");
SearchService
We create the query and issue it, we give it a range of results so we can page through query results like we do with other pageable content

15. return jpaQuery.setFirstResult(page * amount).
setMaxResults(amount).getResultList();
}
public List<UserDAO> searchPeople(String name, int page, int amount) {
List<User> results = genericSearch(name, page, amount,
User.class, "firstName", "familyName");
List<UserDAO> response = new ArrayList<>();
for(User u : results) {
response.add(u.getDAO());
}
return response;
}
public List<PostDAO> searchPosts(String text, int page, int amount) {
List<Post> results = genericSearch(text, page, amount,
Post.class, "title", "content");
List<PostDAO> response = new ArrayList<>();
for(Post p : results) {
response.add(p.getDAO());
}
return response;
}
SearchService
Searching people or posts becomes a matter of passing the entity type, field names & paging numbers

16. }
public List<UserDAO> searchPeople(String name, int page, int amount) {
List<User> results = genericSearch(name, page, amount,
User.class, "firstName", "familyName");
List<UserDAO> response = new ArrayList<>();
for(User u : results) {
response.add(u.getDAO());
}
return response;
}
public List<PostDAO> searchPosts(String text, int page, int amount) {
List<Post> results = genericSearch(text, page, amount,
Post.class, "title", "content");
List<PostDAO> response = new ArrayList<>();
for(Post p : results) {
response.add(p.getDAO());
}
return response;
}
}
SearchService
We then convert the entity result to the DAO object as return types

17. }
public List<UserDAO> searchPeople(String name, int page, int amount) {
List<User> results = genericSearch(name, page, amount,
User.class, "firstName", "familyName");
List<UserDAO> response = new ArrayList<>();
for(User u : results) {
response.add(u.getDAO());
}
return response;
}
public List<PostDAO> searchPosts(String text, int page, int amount) {
List<Post> results = genericSearch(text, page, amount,
Post.class, "title", "content");
List<PostDAO> response = new ArrayList<>();
for(Post p : results) {
response.add(p.getDAO());
}
return response;
}
}
SearchService
Post searches are exactly the same only with Post objects instead of User objects.
That was a bit of code but the premise is relatively simple and the heavy lifting is done by Hibernate. The interesting part is the query builder portion. You can customize
the query builder with any fields you wish to search and complex constraints related to the search. But for the simple implementation we have right now this will do just
fine.