logo

TechCodeview

MVC-arkitektur i Java

Model-View-Controller (MVC) er en velkjent design mønster innen webutvikling. Det er måten å organisere koden vår på. Den spesifiserer at et program eller en applikasjon skal bestå av datamodell, presentasjonsinformasjon og kontrollinformasjon. MVC-mønsteret trenger at alle disse komponentene er atskilt som forskjellige objekter.

I denne delen vil vi diskutere MVC-arkitekturen i Java, sammen med dens fordeler og ulemper og eksempler for å forstå implementeringen av MVC i Java.

Hva er MVC-arkitektur i Java?

Modelldesignene basert på MVC-arkitekturen følger MVC-designmønsteret. Applikasjonslogikken er atskilt fra brukergrensesnittet mens programvaren utformes ved bruk av modelldesign.

vårm

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

    Modell:Det representerer forretningslaget for applikasjonen. Det er et objekt å bære dataene som også kan inneholde logikken for å oppdatere kontrolleren hvis data endres.Utsikt:Den representerer presentasjonslaget for applikasjonen. Den brukes til å visualisere dataene som modellen inneholder.Kontroller:Det fungerer både på modell og visning. Den brukes til å administrere applikasjonsflyten, dvs. dataflyt i modellobjektet og til å oppdatere visningen hver gang data endres.

I Java-programmering inneholder modellen det enkle Java-klasser , visningen som brukes til å vise dataene og kontrolleren inneholder servletter . På grunn av denne separasjonen blir brukerforespørslene behandlet som følger:

MVC-arkitektur i Java
  1. En klient (nettleser) sender en forespørsel til kontrolleren på serversiden om en side.
  2. Kontrolleren kaller deretter modellen. Den samler de forespurte dataene.
  3. Deretter overfører kontrolleren dataene som er hentet til visningslaget.
  4. Nå sendes resultatet tilbake til nettleseren (klienten) av visningen.

Fordeler med MVC-arkitektur

Fordelene med MVC-arkitektur er som følger:

  • MVC har funksjonen skalerbarhet som igjen hjelper veksten av applikasjoner.
  • Komponentene er enkle å vedlikeholde fordi det er mindre avhengighet.
  • En modell kan gjenbrukes av flere visninger som gir gjenbrukbarhet av kode.
  • Utviklerne kan jobbe med de tre lagene (Model, View og Controller) samtidig.
  • Ved å bruke MVC blir applikasjonen mer forståelig.
  • Ved å bruke MVC vedlikeholdes hvert lag separat, derfor trenger vi ikke å håndtere massiv kode.
  • Utvidelse og testing av applikasjonen er enklere.

Implementering av MVC ved hjelp av Java

For å implementere MVC-mønster i Java, må vi lage følgende tre klasser.

    Ansatt klasse, vil fungere som modelllagEmployeeView-klasse, vil fungere som et visningslagEmployeeContoller Class, vil fungere som et kontrollerlag

MVC-arkitekturlag

Modelllag

Modellen i MVC-designmønsteret fungerer som et datalag for applikasjonen. Den representerer forretningslogikken for applikasjonen og også applikasjonstilstanden. Modellobjektet henter og lagrer modelltilstanden i databasen. Ved å bruke modelllaget brukes regler på dataene som representerer applikasjonsbegrepene.

La oss vurdere følgende kodebit som lager en som også er det første trinnet for å 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; } }

Koden ovenfor består ganske enkelt av getter- og settermetoder til Employee-klassen.

Vis lag

Som navnet viser, representerer view visualiseringen av data mottatt fra modellen. Visningslaget består av utdata fra applikasjon eller brukergrensesnitt. Den sender de forespurte dataene til klienten, som hentes fra modelllaget av kontrolleren.

La oss ta et eksempel der vi lager en visning ved å bruke 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); } }

Kontrollerlag

Kontrollerlaget henter brukerforespørslene fra visningslaget og behandler dem, med nødvendige valideringer. Den fungerer som et grensesnitt mellom modell og visning. Forespørslene sendes deretter til modell for databehandling. Når de er behandlet, sendes dataene tilbake til kontrolløren og vises deretter på visningen.

La oss vurdere følgende kodebit som oppretter kontrolleren ved å bruke 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 for å implementere MVC-arkitekturen. Her bruker 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; } }

De MVCMain klasse henter ansattes data fra metoden der vi har lagt inn verdiene. Deretter presser den disse verdiene i modellen. Etter det initialiserer den visningen (EmployeeView.java). Når visningen er initialisert, blir kontrolleren (EmployeeController.java) påkalt og binder den til Employee-klassen og EmployeeView-klassen. Til slutt oppdaterer updateView()-metoden (kontrollermetoden) ansattdetaljene som skal skrives ut til konsollen.

Produksjon: 

 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åten har vi lært om MVC-arkitektur, betydningen av hvert lag og dets implementering i Java.