1. Wie funktioniert SpringMVC?

Der Benutzer sendet eine Anfrage an den Server und die Anfrage wird vom SpringMVC-Front-End-Controller DispatchServlet erfasst.

DispatcherServle analysiert die Anfrage-URL und erh?lt die Anfrageressourcen-ID ( URL) und dann basierend auf der URL HandlerMapping aufrufen, um die Anforderung dem Prozessor HandlerExcutionChain zuzuordnen.

DispatchServlet w?hlt einen geeigneten HandlerAdapter-Adapter für die Verarbeitung basierend auf dem erhaltenen Handler aus.

Nachdem der Handler abgeschlossen ist Bei der Datenverarbeitung wird ein ModelAndView-Objekt an DisPatchServlet zurückgegeben.

Das vom Handler zurückgegebene ModelAndView ist nur eine logische Ansicht und keine formale Ansicht. DispatcherSevlet verwendet ViewResolver, um zu versuchen, die logische Ansicht in eine echte Ansicht zu analysieren.

DispatcherServle analysiert ModelAndView() durch das Modell. Die Parameter werden analysiert und schlie?lich wird die vollst?ndige Ansicht angezeigt und an den Client zurückgegeben ??> 2. Was sind die allgemeinen Anmerkungen von SpringMVC?

@RequestMapping wird verwendet, um eine URL-Zuordnung anzufordern.

Die Annotation @RequestBody implementiert den Empfang von JSON-Daten einer HTTP-Anfrage und die Konvertierung von JSON-Daten in ein Java-Objekt. Die Annotation @ResponseBody wandelt das von der Controller-Methode zurückgegebene Objekt in eine JSON-Antwort an den Kunden um.

In unseren Projekten aktivieren wir normalerweise den Annotationsprozessor und den Adapter, indem wir ihn in springmvc.xml aktivieren.

4. Wie kann das Problem des Abrufens und Postens verstümmelter Zeichen gel?st werden?

Um die verstümmelte Post-Anfrage zu l?sen: Wir k?nnen einen CharacterEncodingFilter-Filter in web.xml konfigurieren. Auf utf-8 setzen. Um den verstümmelten Code der Get-Anfrage zu l?sen, gibt es zwei Methoden. Es gibt zwei L?sungen für die verstümmelten chinesischen Parameter der Get-Anfrage:

?ndern Sie die Tomcat-Konfigurationsdatei, um eine Codierung hinzuzufügen, die mit der technischen Codierung übereinstimmt. Eine andere M?glichkeit, Parameter neu zu kodieren, ist String userName = new String(request.getParameter("userName").getBytes("ISO8859-1"), "utf-8");

Spring ist ein Open-Source-Framework, das entwickelt wurde, um die Anwendungsentwicklung auf Unternehmensebene zu vereinfachen. Spring kann es einfachen JavaBeans erm?glichen, Funktionen zu erreichen, die zuvor nur EJB erreichen konnten. Spring ist ein IOC- und AOP-Container-Framework.

Der Hauptkern des Spring-Containers ist:

Inversion of Control (IOC) Im traditionellen Java-Entwicklungsmodell verwenden wir, wenn ein Objekt ben?tigt wird new uns selbst Oder rufen Sie direkt oder indirekt Konstruktormethoden wie getInstance auf, um ein Objekt zu erstellen. Im Spring-Entwicklungsmodell verwendet der Spring-Container das Fabrikmodell, um die für uns erforderlichen Objekte zu erstellen. Wir k?nnen die von Spring bereitgestellten Objekte direkt aufrufen der Kontrolle.

Abh?ngigkeitsinjektion (DI), Spring verwendet die Set-Methode des JavaBean-Objekts oder die Konstruktormethode mit Parametern, um seine Eigenschaften automatisch auf die erforderlichen Werte festzulegen, wenn wir das erforderliche Objekt erstellen. Dies ist die Idee von ??Abh?ngigkeitsinjektion. Aspektorientierte Programmierung (AOP), in der Idee der objektorientierten Programmierung (oop), extrahieren wir Dinge nacheinander vertikal in Objekte. Bei der aspektorientierten Programmierung extrahieren wir bestimmte ?hnliche Aspekte jedes Objekts horizontal in einen Aspekt und führen einige allgemeine Vorg?nge für diesen Aspekt durch, z. B. Berechtigungskontrolle, Transaktionsverwaltung, Protokollierung usw. Dies ist die Idee der Aspektorientierung Programmierung. Die unterste Ebene von AOP ist ein dynamischer Proxy. Wenn die Schnittstelle einen dynamischen JDK-Proxy verwendet, verwendet die Klasse CGLIB, um einen dynamischen Proxy zu implementieren.

Einzelfallmodus - zwei Proxy-Methoden im Frühjahr Wenn das Zielobjekt mehrere Schnittstellen implementiert, verwendet Spring den Klassenproxy java.lang.reflect.Proxy von jdk. Wenn die Zielimplementierung keine Schnittstelle implementiert, verwendet Spring die CGLIB-Bibliothek, um eine Unterklasse der Zielklasse zu generieren. Singleton-Modus – Stellen Sie die Bean in der Spring-Konfigurationsdatei standardm??ig auf den Singleton-Modus ein.

Vorlagenmodus – wird verwendet, um das Problem der Codeduplizierung zu l?sen. Zum Beispiel: RestTemplate, JmsTemplate, JpaTemplateFront-End-Controller-Modus – Spring stellt den Front-End-Controller DispatherServlet zum Verteilen von Anforderungen bereit.

View-Helfer – Spring bietet eine Reihe von JSP-Tags und effizienten Makros, um die Integration von verstreutem Code in die Ansicht zu unterstützen.

Abh?ngigkeitsinjektion – das Kernkonzept, das über die Schnittstelle BeanFactory/AplacationContext ausgeführt wird.

Factory-Muster – Im Factory-Muster legen wir beim Erstellen eines Objekts die Erstellungslogik nicht für den Client offen und verweisen auf das neu erstellte Objekt, indem wir dieselbe Schnittstelle verwenden. BeanFactory wird in Spring verwendet, um Instanzen von Objekten zu erstellen.

Spring begann ab Version 2.5, Annotationen zum Konfigurieren der Abh?ngigkeitsinjektion zu unterstützen. Anmerkungen k?nnen verwendet werden, um Bean-Beschreibungen in XML zu ersetzen. Die Annotationsinjektion wird vom Container vor der XML-Injektion verarbeitet, sodass letztere die Verarbeitungsergebnisse des ersteren für dasselbe Attribut überschreibt.

Annotation Assembly ist im Frühjahr standardm??ig deaktiviert. Daher müssen Sie es in der Spring Core-Konfigurationsdatei konfigurieren, um den annotationsbasierten Montagemodus zu verwenden. Die Konfigurationsmethode lautet wie folgt:

H?ufig verwendete Anmerkungen:

@Erforderlich: Diese Anmerkung gilt für die Werteinstellungsmethode.

@Autowired: Diese Anmerkung gilt für bewertete Setter-Methoden, Nicht-Setter-Methoden, Konstruktoren und Variablen.

@Qualifier: Diese Annotation wird in Verbindung mit @Autowired verwendet, um die automatische Verkabelung bestimmter Beans eindeutig zu machen.

8. Stellen Sie kurz den Lebenszyklus von Spring Beans vor.

Bean-Definition: Wird in der Konfigurationsdatei zur Definition verwendet.

Bean-Initialisierung: Es gibt zwei M?glichkeiten zur Initialisierung: Dies erfolgt durch Angabe des init-method-Attributs in der Konfigurationsdatei. Implementiert die Schnittstelle org.springframework.beans.factory.InitializingBean.

Bean-Aufruf: Es gibt drei M?glichkeiten, eine Bean-Instanz abzurufen und aufzurufen

Bean-Zerst?rung: Es gibt zwei M?glichkeiten zur Zerst?rung: Verwenden Sie das in der Konfigurationsdatei angegebene Attribut destroy-method. Implementiert org.springframework.bean.factory.DisposeableBean.

9. Verstehen Sie das Federstrukturdiagramm?

Core-Container: einschlie?lich Core-, Beans-, Kontext- und EL-Module. Kernmodul: Kapselt den untersten Teil der Framework-Abh?ngigkeiten, einschlie?lich Ressourcenzugriff, Typkonvertierung und einige g?ngige Toolklassen.

Beans-Modul: Stellt die grundlegenden Teile des Frameworks bereit, einschlie?lich der Umkehrung der Kontrolle und der Abh?ngigkeitsinjektion. Unter anderem ist BeanFactory der Kern des Containers. Es ist im Wesentlichen die Implementierung des ?Factory-Design-Musters“ und erfordert keine Programmierung, um das ?Single-Case-Design-Muster“ zu implementieren. Der Single-Case wird vollst?ndig vom Container gesteuert und befürwortet die Schnittstelle -orientierte Programmierung statt umsetzungsorientierte Programmierung; alle Anwendungsobjekte und die Beziehungen zwischen Objekten werden vom Framework verwaltet, das die Abh?ngigkeiten zwischen verwalteten Objekten wirklich aus der Programmlogik extrahiert. Alle diese Abh?ngigkeiten werden von BeanFactory verwaltet.

Kontextmodul: Basierend auf Core und Beans integriert es die Funktionen des Beans-Moduls und fügt Ressourcenbindung, Datenvalidierung, Internationalisierung, JavaEE-Unterstützung, Container-Lebenszyklus, Ereignisweitergabe usw. hinzu; die Kernschnittstelle ist ApplicationContext.

EL-Modul: Bietet leistungsstarke Unterstützung für Ausdruckssprachen, unterstützt den Zugriff und die ?nderung von Attributwerten, Methodenaufrufen, unterstützt den Zugriff und die ?nderung von Arrays, Containern und Indexern, benannten Variablen, unterstützt arithmetische und logische Operationen und unterstützt die Ausführung von Spring The Der Container erh?lt die Bean, die auch Listenprojektion, Auswahl und allgemeine Listenaggregation unterstützt.

AOP, Aspects-Modul: AOP-Modul: Das Spring AOP-Modul bietet eine aspektorientierte Programmierimplementierung, die der AOPAlliance-Spezifikation entspricht und allgemeine Funktionen wie Protokollierung, Berechtigungskontrolle, Leistungsstatistiken usw. sowie Gesch?ftslogik-Trennungstechnologie bereitstellt und kann diese Funktionen dynamisch zum erforderlichen Code hinzufügen. Auf diese Weise ist jede einzelne ihren eigenen Aufgaben gewidmet und verringert die Kopplung zwischen Gesch?ftslogik und allgemeinen Funktionen.

Aspects-Modul: Bietet die Integration von AspectJ, das leistungsf?higere Funktionen als SpringASP bietet. Datenzugriffs-/Integrationsmodul: Dieses Modul umfasst JDBC, ORM, OXM, JMS und Transaktionsmanagement.

Transaktionsmodul: Dieses Modul wird für Spring-Verwaltungstransaktionen verwendet. Solange Spring Objekte verwaltet, k?nnen sie die Vorteile von Spring-Verwaltungstransaktionen nutzen. Es besteht keine Notwendigkeit, Transaktionen im Code zu steuern, und es unterstützt die Programmierung und deklaratives Transaktionsmanagement.

JDBC-Modul: Stellt eine JBDC-Beispielvorlage bereit. Durch die Verwendung dieser Vorlagen kann die traditionelle langwierige JDBC-Codierung und die notwendige Transaktionskontrolle entfallen und Sie k?nnen die Vorteile der Transaktionsverwaltung von Spring nutzen.

ORM-Modul: Bietet nahtlose Integration mit g?ngigen ?objektrelationalen“ Mapping-Frameworks, einschlie?lich Hibernate, JPA, MyBatis usw. Und Sie k?nnen das Spring-Transaktionsmanagement ohne zus?tzliche Transaktionskontrolle verwenden.

OXM-Modul: Bietet eine Implementierung der Objekt-/XML-Zuordnung, die Zuordnung von Java-Objekten zu XML-Daten oder die Zuordnung von XML-Daten zu Java-Objekten. Zu den Objekt-/XML-Zuordnungsimplementierungen geh?ren JAXB, Castor, XMLBeans und XStream.

JMS-Modul: Wird für JMS (JavaMessagingService) verwendet und stellt eine Reihe von ?Nachrichtenproduzenten, Nachrichtenkonsumenten“-Vorlagen zur einfacheren Verwendung von JMS zur Verfügung, die zwischen zwei Anwendungen zum asynchronen Senden verwendet werden Kommunikation. Web/Remoting-Modul: Das Web/Remoting-Modul umfasst Web-, Web-Servlet-, Web-Struts- und Web-Portlet-Module.

Webmodul: Bietet grundlegende Webfunktionen. Beispielsweise werden mehrere Datei-Uploads, integrierte IoC-Container, Remote-Prozesszugriff (RMI, Hessian, Burlap) und WebService-Unterstützung sowie eine RestTemplate-Klasse bereitgestellt, um einen bequemen Restfulservices-Zugriff zu erm?glichen.

Web-Servlet-Modul: Bietet eine SpringMVCWeb-Framework-Implementierung. Das SpringMVC-Framework bietet annotationsbasierte Anforderungsressourceninjektion, einfachere Datenbindung, Datenvalidierung usw. sowie eine Reihe sehr benutzerfreundlicher JSP-Tags, die v?llig nahtlos mit anderen Spring-Technologien zusammenarbeiten.

Web-Struts-Modul: Bietet eine nahtlose Integration mit Struts.x und Struts2.x unterstützen Testmodul: Spring unterstützt Junit- und TestNG-Testframeworks und bietet auch einige zus?tzliche Testfunktionen, die auf Spring basieren B. die Simulation der Funktion von HTTP-Anfragen beim Testen von Web-Frameworks.

10. Wobei kann uns der Frühling helfen?

Spring kann uns helfen, Abh?ngigkeiten zwischen Objekten basierend auf Konfigurationsdateien zu erstellen und zusammenzustellen.

Spring erstellt und stellt Abh?ngigkeiten zwischen Objekten basierend auf der Konfigurationsdatei zusammen.

Die aspektorientierte Programmierung von Spring kann uns bei der Implementierung der Protokollierung ohne Kopplung helfen. Leistungsstatistiken, Sicherheitskontrolle.

Spring-aspektorientierte Programmierung kann eine bessere M?glichkeit zur Vervollst?ndigung bieten, normalerweise durch Konfiguration, und erfordert kein Hinzufügen von zus?tzlichem Code zum vorhandenen Code. Der vorhandene Code konzentriert sich auf die Gesch?ftslogik.

Spring kann uns dabei helfen, Datenbanktransaktionen sehr einfach zu verwalten.

Mit Spring müssen wir nur die Verbindung herstellen und SQL ausführen, und alle anderen damit verbundenen Dinge werden von Spring verwaltet.

Spring kann auch nahtlos in Datenbankzugriffs-Frameworks von Drittanbietern (wie Hibernate, JPA) integriert werden und bietet au?erdem eine Reihe von JDBC-Zugriffsvorlagen, um den Datenbankzugriff zu erleichtern.

Spring kann auch nahtlos in Web-Frameworks von Drittanbietern (wie Struts, JSF) integriert werden und bietet au?erdem eine Reihe von SpringMVC-Frameworks, um den Aufbau der Webschicht zu erleichtern.

Spring kann problemlos in JavaEE (z. B. JavaMail, Aufgabenplanung) und weitere Technologien (z. B. Caching-Framework) integriert werden.

11. Bitte beschreiben Sie die Angelegenheiten des Frühlings?

Definition der deklarativen Transaktionsverwaltung: Verwenden Sie die deklarative Transaktionsverarbeitung in Spring-Konfigurationsdateien anstelle von Codeverarbeitungstransaktionen. Dies hat den Vorteil, dass die Transaktionsverwaltung nicht in die entwickelten Komponenten eingreift. Insbesondere erkennen die Gesch?ftslogikobjekte nicht, dass sie von der Transaktion verwaltet werden. Dies sollte tats?chlich der Fall sein, da es sich bei der Transaktionsverwaltung um einen Dienst handelt Wenn Sie den Transaktionsverwaltungsplan ?ndern m?chten, müssen Sie ihn nur in der Definitionsdatei neu konfigurieren, was ?u?erst einfach zu verwalten ist.

Deklaratives Transaktionsmanagement basierend auf TransactionInterceptor: zwei Hauptattribute: ?transactionManager“ wird verwendet, um einen Transaktionsmanager anzugeben und ihm bestimmte transaktionsbezogene Vorg?nge anzuvertrauen. Das andere ist das Attribut ?transactionAttributes“ vom Typ ?Properties“ in jedem Schlüssel -Wertpaar dieses Attributs, der Schlüssel gibt den Methodennamen an, der Methodenname kann Platzhalter verwenden und der Wert stellt das Transaktionsattribut dar, das von der entsprechenden Methode verwendet wird.

<beans>
    ......
    <bean id="transactionInterceptor"
          class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <property name="transactionManager" ref="transactionManager"/>
        <property name="transactionAttributes">
            <props>
                <prop key="transfer">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
    </bean>
    <bean id="bankServiceTarget"
          class="footmark.spring.core.tx.declare.origin.BankServiceImpl">
        <property name="bankDao" ref="bankDao"/>
    </bean>
    <bean id="bankService"
          class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="bankServiceTarget"/>
        <property name="interceptorNames">
            <list>
                <idref bean="transactionInterceptor"/>
            </list>
        </property>
    </bean>
</beans>

Deklaratives Transaktionsmanagement basierend auf TransactionProxyFactoryBean: Das Einrichten der Konfigurationsdatei ist viel einfacher als zuvor. Wir nennen diese Art der Einstellung des Konfigurationsdateiformats das klassische deklarative Transaktionsmanagement von Spring.

<beans>
    ......
    <bean id="bankServiceTarget"
          class="footmark.spring.core.tx.declare.classic.BankServiceImpl">
        <property name="bankDao" ref="bankDao"/>
    </bean>
    <bean id="bankService"
          class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <property name="target" ref="bankServiceTarget"/>
        <property name="transactionManager" ref="transactionManager"/>
        <property name="transactionAttributes">
            <props>
                <prop key="transfer">PROPAGATION_REQUIRED</prop>
            </props>
        </property>
    </bean>
</beans>

Deklarative Transaktionsverwaltung basierend auf Namespace: Basierend auf den ersten beiden Methoden führt Spring 2.x Namespace ein und verwendet Namespace in Kombination, um Entwicklern die M?glichkeit zu geben, deklarative Transaktionen zu konfigurieren. Eine neue Erfahrung.

<beans>
    ......
    <bean id="bankService"
          class="footmark.spring.core.tx.declare.namespace.BankServiceImpl">
        <property name="bankDao" ref="bankDao"/>
    </bean>
    <tx:advice id="bankAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="transfer" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="bankPointcut" expression="execution(* *.transfer(..))"/>
        <aop:advisor advice-ref="bankAdvice" pointcut-ref="bankPointcut"/>
    </aop:config>
    ......
</beans>

Deklaratives Transaktionsmanagement basierend auf @Transactional: Spring 2.x führt auch einen annotationsbasierten Ansatz ein, der haupts?chlich die @Transactional-Annotation umfasst. @Transactional kann auf Schnittstellen, Schnittstellenmethoden, Klassen und Klassenmethoden angewendet werden. Wenn die Berechnung auf eine Klasse angewendet wird, verfügen alle ?ffentlichen Methoden der Klasse über Transaktionsattribute dieses Typs.

@Transactional(propagation = Propagation.REQUIRED)
public boolean transfer(Long fromId, Long toId, double amount) {
    return bankDao.transfer(fromId, toId, amount);
}

Die Definition der programmgesteuerten Transaktionsverwaltung: Wenn Sie beginTransaction (), commit (), rollback () und andere Methoden zur Transaktionsverwaltung explizit im Code aufrufen, handelt es sich um programmgesteuerte Transaktionsverwaltung. Die programmgesteuerte Verwaltung von Dingen durch Spring verfügt über zwei Methoden: programmgesteuerte Verwaltung basierend auf der zugrunde liegenden API und programmgesteuerte Transaktionsverwaltung basierend auf TransactionTemplate.

Programmatische Verwaltung basierend auf der zugrunde liegenden API: Credentials PlatformTransactionManager, TransactionDefinition und TransactionStatus drei Kernschnittstellen zur Implementierung der programmgesteuerten Transaktionsverwaltung.

public class BankServiceImpl implements BankService {
    private BanckDao bankDao;
    private TransactionDefinition txDefinition;
    private PlatformTransactionManager txManager;

    public boolean transfer(Long fromId, Long toId, double amount) {
        TransactionStatus txStatus = txManager.getTransaction(txDefinition);
        boolean result = false;
        try {
            result = bankDao.transfer(fromId, toId, amount);
            txManager.commit(txStatus);
        } catch (Exception e) {
            result = false;
            txManager.rollback(txStatus);
            System.out.println("Transfer Error!");
        }
        return result;
    }
}

Programmatische Transaktionsverwaltung basierend auf TransactionTemplate: Um die ursprüngliche Organisation des Codes nicht zu besch?digen und das Ph?nomen zu vermeiden, dass jede Methode denselben Boilerplate-Code zum Starten, Senden und Zurücksetzen von Dingen enth?lt, bietet Spring Folgendes an Die TransactionTemplate-Vorlage wird zum Implementieren der programmgesteuerten Transaktionsverwaltung verwendet.

public class BankServiceImpl implements BankService {
    private BankDao bankDao;
    private TransactionTemplate transactionTemplate;

    public boolean transfer(final Long fromId, final Long toId, final double amount) {
        return (Boolean) transactionTemplate.execute(new TransactionCallback() {
            public Object doInTransaction(TransactionStatus status) {
                Object result;
                try {
                    result = bankDao.transfer(fromId, toId, amount);
                } catch (Exception e) {
                    status.setRollbackOnly();
                    result = false;
                    System.out.println("Transfer Error!");
                }
                return result;
            }
        });
    }
}

Der Unterschied zwischen programmatischen Transaktionen und deklarativen Transaktionen:

Programmatische Transaktionen bestehen darin, die Transaktionsverarbeitungsklasse selbst zu schreiben und sie dann aufzurufen.

Deklarative Transaktionen werden in Konfigurationsdateien konfiguriert und im Allgemeinen in Frameworks verwendet.

Das obige ist der detaillierte Inhalt vonDie neuesten Java-Interviewfragen: Teil des Spring-Frameworks. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!