Spring Boot | Using a separate file for logic-CodePudding

I am writing a small CRUD in Spring and Java. And I want to use a separate file for writing logic, this is very convenient for me, I did this when developing with NestJS. I have a few questions, is it correct to do this in Spring, or should I do everything inside a function in the controller. And if I write logic in a separate file, I should mark the logic class as @Component and the functions inside it as @Bean, right? I am new to Spring and as I understand it, I have to do this in order for the application to work correctly and my functions to be in the application context.

AuthLogic.java

@Component
public class AuthLogic {
   @Bean
   public void register() {
       // code ... 
   }
}

AuthController.java

 @RestController
 public class AuthController {
    @RequestMapping(value = "/register", method = RequestMethod.POST)
    @ResponseStatus(HttpStatus.CREATED)
    public void register(@Valid @RequestBody UserDTO newUser) {
       // here I call the register function from AuthLogic
    }
 }

CodePudding user response：

You can write your business logic in a new separate file at service layer. Suppose you name it as AuthService and you mark it with annotation @Service.

@Service
public class AuthService{
}

You can then Autowire it in your controller class.

@RestController
public class AuthController {

    @Autowired
    AuthService authService;
    
    @RequestMapping(value = "/register", method = RequestMethod.POST)
    @ResponseStatus(HttpStatus.CREATED)
    public void register(@Valid @RequestBody UserDTO newUser) {
       // here I call the register function from AuthLogic
    }
 }

CodePudding user response：

you can mark your logic class with @Service and use that for example you can make a AuthService and use it like

@Service
public class AuthService{
      public returnType login(){
//Logic
 }
}

and use this like

 @RestController
 public class AuthController {
     
     AuthService authService;
    
    @RequestMapping(value = "/register", method = RequestMethod.POST)
    @ResponseStatus(HttpStatus.CREATED)
    public void register(@Valid @RequestBody UserDTO newUser) {
       authService.login();
    }
 }

CodePudding user response：

There is no specific layout or code structure for Spring Boot Projects. However, there are some best practices followed by developers that will help us too. You can divide your project into layers like service layer, entity layer, and repository layer.

We use the entity layer to write all model and POJO classes.
we use @Repositry to indicate that this is a repository class that is used to do some basic crud operations, Even though if you don't write @Repositry it will work because spring automatically detects repository classes if they are extending any other repository. We al put repositories in repository layer
We use @Service to say that this is the service class where your all business Logic will be there.
We use the controller layer to receive HTTP Requests and send back HTTP Responses or views.

You can learn and understand more from here

You can refer to this Image to understand the structure project structure

CodePudding user response：

Using separate files, or classes more importantly, is very recommended in Spring, and I assume most other languages.

The @Bean annotation on AuthLogic.java is unneeded and I think may cause startup or compilation errors.

I would change the name of AuthLogic to AuthLogicImpl, create an interface named AuthLogic with the method signature void register(), and have AuthLogicImpl implement AuthLogic. Then you can create a constructor for AuthController which accepts and AuthLogic parameter and sets it to a private field (note using the interface not the implementation in the constructor).

At the core of Spring is the IoC container. This container holds "beans" that can be injected or autowired into other beans. These beans are an instance of their class and can be used by other beans. Remember Spring uses the singleton pattern, so your beans should be stateless. This allows Spring to handle the application startup for you, so you don't need to write a ton of code creating all the different services/classes and wiring them together, it's all automagically done for you.

There are two key annoitations that you appear to be confused about:

@Component Putting this above a class will create an instance of that class (a bean) and put it into the IoC container. Other beans can access this by accepting the original beans interface in its constructor. So if I put @Component above my class FooImpl which implements Foo, then I can create a class, BarImpl with the constructor public BarImpl(Foo foo) {this.foo = foo} and BarImpl can use any public method of Foo (which will use FooImpl's implementation).

@Bean this is to be put on a method of a class that is annotated with @Configuration. This tells Spring that this method should be run at startup, and this method will return a bean that Spring should add to the IoC container. This is a popular way of configuring a bean that requires some parameters, such as the bean that manages the connection to a third party service or datastore, especially when that there is a little bit of logic that needs to go into creating the bean.

Note that the above is very broad, and there are some specifics if you need to dig deep into the spring framework, so there will be more clarification in the Spring documentation or you dig into some established Spring project. However it should suffice to answer the broad question of what is going on with @Component and @Bean.