logo

TechCodeview

MVC-arkitektur i Java

Model-View-Controller (MVC) er en velkendt design mønster inden for webudviklingsområdet. Det er måden at organisere vores kode på. Det specificerer, at et program eller en applikation skal bestå af datamodel, præsentationsinformation og kontrolinformation. MVC-mønsteret kræver, at alle disse komponenter adskilles som forskellige objekter.

I dette afsnit vil vi diskutere MVC-arkitekturen i Java sammen med dens fordele og ulemper og eksempler for at forstå implementeringen af ​​MVC i Java.

Hvad er MVC-arkitektur i Java?

Modeldesignerne baseret på MVC-arkitekturen følger MVC-designmønster. Applikationslogikken er adskilt fra brugergrænsefladen, mens softwaren designes ved hjælp af modeldesign.

windows.åbn javascript

MVC-mønsterarkitekturen består af tre lag:

    Model:Det repræsenterer applikationens forretningslag. Det er et formål at bære de data, der også kan indeholde logikken til at opdatere controlleren, hvis data ændres.Udsigt:Det repræsenterer præsentationslaget af applikationen. Det bruges til at visualisere de data, som modellen indeholder.Controller:Det virker på både model og visning. Det bruges til at styre applikationsflowet, dvs. dataflow i modelobjektet og til at opdatere visningen, hver gang data ændres.

I Java-programmering indeholder modellen det enkle Java klasser , den visning, der bruges til at vise dataene, og controlleren indeholder servlets . På grund af denne adskillelse behandles brugeranmodningerne som følger:

MVC-arkitektur i Java
  1. En klient (browser) sender en anmodning til controlleren på serversiden om en side.
  2. Controlleren kalder derefter modellen. Den indsamler de ønskede data.
  3. Derefter overfører controlleren de hentede data til visningslaget.
  4. Nu sendes resultatet tilbage til browseren (klienten) af visningen.

Fordele ved MVC-arkitektur

Fordelene ved MVC-arkitektur er som følger:

  • MVC har funktionen af ​​skalerbarhed, der igen hjælper med væksten af ​​applikationer.
  • Komponenterne er nemme at vedligeholde, fordi der er mindre afhængighed.
  • En model kan genbruges af flere visninger, der giver genanvendelighed af kode.
  • Udviklerne kan arbejde med de tre lag (Model, View og Controller) samtidigt.
  • Ved at bruge MVC bliver applikationen mere forståelig.
  • Ved hjælp af MVC vedligeholdes hvert lag separat, derfor behøver vi ikke håndtere massiv kode.
  • Udvidelsen og afprøvningen af ​​applikationen er lettere.

Implementering af MVC ved hjælp af Java

For at implementere MVC-mønster i Java, skal vi oprette følgende tre klasser.

    Medarbejderklasse, vil fungere som modellagEmployeeView klasse, vil fungere som et visningslagMedarbejderKontroller klasse, vil fungere som et controller-lag

MVC arkitekturlag

Model lag

Modellen i MVC-designmønsteret fungerer som et datalag for applikationen. Det repræsenterer forretningslogikken for applikationen og også applikationstilstanden. Modelobjektet henter og gemmer modeltilstanden i databasen. Ved hjælp af modellaget anvendes regler på de data, der repræsenterer anvendelsesbegreberne.

Lad os overveje følgende kodestykke, der opretter et, hvilket også er det første skridt til at implementere MVC-mønster.

Employee.java 

 // class that represents model public class Employee { // declaring the variables private String EmployeeName; private String EmployeeId; private String EmployeeDepartment; // defining getter and setter methods public String getId() { return EmployeeId; } public void setId(String id) { this.EmployeeId = id; } public String getName() { return EmployeeName; } public void setName(String name) { this.EmployeeName = name; } public String getDepartment() { return EmployeeDepartment; } public void setDepartment(String Department) { this.EmployeeDepartment = Department; } }

Ovenstående kode består simpelthen af ​​getter- og setter-metoder til Employee-klassen.

Se lag

Som navnet viser, repræsenterer view visualiseringen af ​​data modtaget fra modellen. Visningslaget består af output fra applikation eller brugergrænseflade. Den sender de anmodede data til klienten, som hentes fra modellaget af controlleren.

Lad os tage et eksempel, hvor vi opretter en visning ved hjælp af EmployeeView-klassen.

EmployeeView.java 

 // class which represents the view public class EmployeeView { // method to display the Employee details public void printEmployeeDetails (String EmployeeName, String EmployeeId, String EmployeeDepartment){ System.out.println('Employee Details: '); System.out.println('Name: ' + EmployeeName); System.out.println('Employee ID: ' + EmployeeId); System.out.println('Employee Department: ' + EmployeeDepartment); } }

Controller lag

Controllerlaget henter brugeranmodninger fra visningslaget og behandler dem med de nødvendige valideringer. Det fungerer som en grænseflade mellem Model og View. Anmodningerne sendes derefter til model til databehandling. Når de er behandlet, sendes dataene tilbage til controlleren og vises derefter på visningen.

Lad os overveje følgende kodestykke, der opretter controlleren ved hjælp af EmployeeController-klassen.

EmployeeController.java 

 // class which represent the controller public class EmployeeController { // declaring the variables model and view private Employee model; private EmployeeView view; // constructor to initialize public EmployeeController(Employee model, EmployeeView view) { this.model = model; this.view = view; } // getter and setter methods public void setEmployeeName(String name){ model.setName(name); } public String getEmployeeName(){ return model.getName(); } public void setEmployeeId(String id){ model.setId(id); } public String getEmployeeId(){ return model.getId(); } public void setEmployeeDepartment(String Department){ model.setDepartment(Department); } public String getEmployeeDepartment(){ return model.getDepartment(); } // method to update view public void updateView() { view.printEmployeeDetails(model.getName(), model.getId(), model.getDepartment()); } }

Hovedklasse Java-fil

Følgende eksempel viser hovedfilen til implementering af MVC-arkitekturen. Her bruger vi MVCMain-klassen.

MVCMain.java 

 // main class public class MVCMain { public static void main(String[] args) { // fetching the employee record based on the employee_id from the database Employee model = retriveEmployeeFromDatabase(); // creating a view to write Employee details on console EmployeeView view = new EmployeeView(); EmployeeController controller = new EmployeeController(model, view); controller.updateView(); //updating the model data controller.setEmployeeName('Nirnay'); System.out.println('
 Employee Details after updating: '); controller.updateView(); } private static Employee retriveEmployeeFromDatabase(){ Employee Employee = new Employee(); Employee.setName('Anu'); Employee.setId('11'); Employee.setDepartment('Salesforce'); return Employee; } }

Det MVCMain klasse henter medarbejderdataene fra den metode, hvor vi har indtastet værdierne. Så skubber det disse værdier i modellen. Derefter initialiserer den visningen (EmployeeView.java). Når visningen initialiseres, aktiveres controlleren (EmployeeController.java) og binder den til Employee-klassen og EmployeeView-klassen. Til sidst opdaterer updateView()-metoden (controllermetoden) medarbejderoplysningerne, der skal udskrives til konsollen.

Produktion: 

 Employee Details: Name: Anu Employee ID: 11 Employee Department: Salesforce Employee Details after updating: Name: Nirnay Employee ID: 11 Employee Department: Salesforce

På denne måde har vi lært om MVC-arkitektur, betydningen af ​​hvert lag og dets implementering i Java.