Die neuesten Java-Interviewfragen: Teil des Spring-Frameworks

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.

3. Wie aktiviere ich den Anmerkungsprozessor und den Adapter?

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");

5. Erzählen Sie uns von Ihrem Verständnis von Spring?

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.

6. Was sind die Entwurfsmuster in Spring?

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.

7. Allgemeine Anmerkungen zum Frühling?

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!