Spring MVC Architecture Pattern Identification

Question

I work through the spring mvc video series and love it!

• https://www.youtube.com/channel/UCcawgWKCyddtpu9PP_Fz-tA/videos

I would like to know more about the specifics of the exact architecture used, and it is difficult for me to determine the correct name so that I can read further.

For example, I understand that the level of presentation is MVC, but I’m not quite sure how you more specifically describe the template for accounting for the use of service objects and resources - as opposed to choosing to use services, DAO and Domain objects.

Any tips to help me better focus my search on understanding the layout below?

application core models/entities services rest controllers resources resource_assemblers 

Edit: A comment by Nathan Hughes clarified my confusion in the nomenclature, and SirKometa connected architectural points that I missed. Thank you, guys.

Answer 1

As far as I can tell you what you mentioned represents an application that communicates with the world through REST services.

• core package represents all classes (domain, services, repositories) that are not associated with the view.
• model package - Assuming you are targeting a typical application, you have a model/domain/entity package that represents your data For example: https://github.com/chrishenkel/spring-angularjs-tutorial-10/blob/master/ src / main / java / tutorial / core / models / entities / Account.java .
• repository package. Since you are using Spring, you will most likely also use spring-data or even spring-data-jpa with Hibernate as your ORM library. Most likely, this will lead you to use the repository interfaces (the author of the videos on which for some reason you decided not to use it). In any case, your layer will have access to the database, for example: https://github.com/chrishenkel/spring-angularjs-tutorial-10/blob/master/src/main/java/tutorial/core/repositories/jpa /JpaAccountRepo.java
• service package will be your data management package. This is not a good example, but this level does not have direct access to your database, it will use repositories for this, but it can also do other things - it will be your API for data management in your application. Say you want you to have a fantastic calculation on your wallet before you save it to the database, or as here https://github.com/chrishenkel/spring-angularjs-tutorial-10/blob/master/src/ main / java / tutorial / core / services / impl / AccountServiceImpl.java you want to make sure that the blog you are trying to create does not exist yet.
• controllers contains all the classes that DispacherServlet will use to execute queries. You will read "enter" from the request, process it (use Services here) and send your answers.
• resource_assemblers package in this case is platform specific ( Hateoas ). As far as I can tell, this is only DTO for your json answers (for example, you might want to save the password in your Account , but exposing it via json would not be a good idea, and this will happen if you haven't used to).

Please let me know if this is the answer you were looking for.

Answer 2

This question may interest you, and this is an explanation .

Basically you are talking about the same things, Spring just uses annotations, so when it scans them, it knows what type of object you are creating or creating.

Basically, all requests are sent through a controller annotated using @Controller . Each method processes the request and (if necessary) calls a specific class of service for processing business logic. These classes are annotated using @Service . The controller can create these classes by auto-updating them in @Autowire or storing them with @Resource.

 @Controller @RequestMapping("/") public class MyController { @Resource private MyServiceLayer myServiceLayer; @RequestMapping("/retrieveMain") public String retrieveMain() { String listOfSomething = myServiceLayer.getListOfSomethings(); return listOfSomething; } } 

Service classes then execute their business logic and, if necessary, retrieve data from the repository class annotated with @Repository . The service layer creates these classes the same way, either by auto-arranging them in @Autowire or their resource @ Resource .

 @Service public class MyServiceLayer implements MyServiceLayerService { @Resource private MyDaoLayer myDaoLayer; public String getListOfSomethings() { List<String> listOfSomething = myDaoLayer.getListOfSomethings(); // Business Logic return listOfSomething; } } 

Repository classes make up the DAO, Spring uses the @Repository annotation. Objects are individual class objects obtained by the @Repository level.

 @Repository public class MyDaoLayer implements MyDaoLayerInterface { @Resource private JdbcTemplate jdbcTemplate; public List<String> getListOfSomethings() { // retrieve list from database, process with row mapper, object mapper, etc. return listOfSomething; } } 

@Repository, @Service and @Controller are concrete instances of @Component . All of these layers can be annotated using @Component, it’s just better to call it what it really is.

So, to answer your question, they mean the same thing, they are simply annotated so that Spring knows what type of object it creates and / or how to include another class.

Answer 3

I assume that the architectural pattern you are looking for is Representative State Transfer (REST). You can read here:

http://en.wikipedia.org/wiki/Representational_state_transfer

In the framework of REST, the transmitted data is called resources:

Resource Identification : Individual resources are identified in requests, for example, using URIs in REST web systems. The resources themselves are conceptually separated from the views that are returned to the client. For example, a server can send data from its database in the form of HTML, XML or JSON, none of which is an internal representation of the server, and this is the same resource independently.