Erstellen Sie Ideen für die Integration von Projekten und SSM-Frameworks

Erstens, erstellen Sie ein Projekt

Da springMVC später konfiguriert wird, erstellen Sie ein Maven-Projekt mit dem IDEA-Web-Skelett.

Bild

Erstellen Sie das Projektverzeichnis wie folgt: Gleichzeitig wurden die für das Projekt erforderlichen Pakete und Dateien manuell erstellt:

Bild

In der obigen Abbildung ist application.xml die Spring-Konfigurationsdatei, log4j die Log-Konfigurationsdatei und springMVC.xml die springMVC-Konfigurationsdatei

Konfigurieren Sie die erforderlichen Abhängigkeiten in der Datei pom.xml. Die Abhängigkeiten des gesamten Projekts lauten wie folgt.

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.hust.demo-ssm</groupId>
  <artifactId>demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>demo Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>5.0.2.RELEASE</spring.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <mysql.version>5.1.6</mysql.version>
    <mybatis.version>3.4.5</mybatis.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.8</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

    <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>

    <!-- log end -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>

    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.0</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>demo</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

</ pre>

Zu diesem Zeitpunkt wurde das Grundgerüst des Projekts erstellt und die Abhängigkeiten des Projekts wurden importiert. Anschließend werde ich die Idee der Integration vorstellen.

2. Ideen zur SSM-Integration

In Bezug auf den Zweck muss die Serviceschicht nach der Integration in der Lage sein, Methoden der Dao-Schicht durch Abhängigkeitsinjektion aufzurufen, und die Controller-Schicht muss Methoden der Serviceschicht durch Abhängigkeitsinjektion aufrufen. Daher besteht die Grundidee der Integration darin, mit spring mybatis und springMVC zu integrieren.

Bild

Mybatis-Konfiguration

Zuerst konfigurieren wir zuerst das mybatis-Framework.

Erstellen Sie zunächst die Datenbank demo_ssm und die Kontotabelle

Die SQL-Anweisung lautet wie folgt:

CREATE DATABASE `demo_ssm`;
USE `demo_ssm`;
DROP TABLE IF EXISTS `account`;
CREATE TABLE `account`(
    `id` INT(11) NOT NULL AUTO_INCREMENT,
    `name` VARCHAR(32),
    `money` DOUBLE,
    PRIMARY KEY(`id`)
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `account`(`name`,`money`) VALUES('赵敏',99999.99),('张无忌',11111.1),('木婉清',22222.22);

</ pre>

2. Erstellen Sie eine Kontoentitätsklasse:

public class Account implements Serializable {
    private Integer id;
    private String name;
    private Double money;
 //getter and setter
 //toString
}

</ pre>

Drittens verwenden Sie Anmerkungen, um die Persistenzschichtschnittstelle zu entwickeln

package com.hust.dao;

public interface IAccountDao {

    @Select("select * from account")
    public List<Account> findAllAccount();
}

</ pre>

Zu diesem Zeitpunkt ist Mybatis konfiguriert. Zu diesem Zeitpunkt wurde die Datenquelle noch nicht konfiguriert. Bei der Integration von Spring warten wir auf die Konfiguration und den Test.

Federkonfiguration und Integration von Mybatis

Erstens die Federkonfiguration

Zu diesem Zeitpunkt Konfiguration der Datei applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--    配置扫描-->
    <context:component-scan base-package="com.hust">
        <context:exclude-filter type="annotation"  expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>
</beans>

</ pre>

wichtiger Punkt:

Die automatische Baugruppe muss die Anmerkungen im Paket scannen. Daher muss die Konfiguration so konfiguriert werden, dass das Scannen von Anmerkungen aktiviert wird. Es gibt zwei Möglichkeiten, das Scannen von Anmerkungen zu aktivieren: <context: annotation-config /> und <context: component-scan>. Die Ähnlichkeiten und Unterschiede zwischen den beiden sind wie folgt:

<context: annotation-config>: Das Scannen von Anmerkungen gilt für Beans, die im Spring-Container registriert wurden

<context: component-scan>: Hat nicht nur alle Funktionen von <context: annotation-config>, sondern scannt auch die entsprechende Bean unter dem angegebenen Paket

Zweitens integriert Spring Mybatis

Denkanalyse:

Das Mybatis-Framework kann automatisch ein Proxy-Objekt generieren. Daher haben wir für die Persistenzschicht nur eine Schnittstelle und Anmerkungen geschrieben. Die spezifische Implementierungsklasse wird vom Framework für uns vervollständigt. Die CRUD der Datenbank wird auch über dieses Proxy-Objekt implementiert. Solange wir das generierte Proxy-Objekt im Container speichern und vom Spring-Framework steuern lassen können, ist die Integration daher erfolgreich.

Ein weiterer wichtiger Punkt ist, dass das Mybatis-Framework die SqlSessionFactory-Factory-Instanz verwendet, um eine SqlSession-Instanz zu erstellen. Über die SqlSession-Instanz können wir die Datenbank betreiben.

Kurz gesagt, der Schlüssel zur Spring-Integration in Mybatis besteht darin, dem Container die Steuerung der SqlSessionFactoryBean-Klasse zu ermöglichen.

Spezifische Platzierung

Die spezifische Konfiguration ist in drei Teile unterteilt:

1. Konfigurieren Sie die Verbindung **** pool ****. 2. Konfigurieren Sie die sqlSession-Factory-Klasse. 3. Konfigurieren Sie den Scanner für das Scannen von Paketen

Die Konfiguration ist also wie folgt:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!--    配置扫描-->
    <context:component-scan base-package="com.hust">
    </context:component-scan>

    <!--    配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///demo_ssm"/>
        <property name="user" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--    配置SqlSession的工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--  配置扫描的包  -->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.hust.dao"/>
    </bean>
</beans>

</ pre>

Nach dieser Konfiguration kann der Spring-Container die sqlSession-Factory-Klasse erstellen. Fügen Sie dann die Annotation @Repository zu IAccountDao hinzu, und das Proxy-Objekt der AccountDao-Schnittstelle kann vom Container verwaltet und integriert werden. Testen wir es mit der Testklasse:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class SpringTest {

    @Autowired
    private IAccountDao accountDao;

    @Test
    public void testSpring(){
        List<Account> accounts = accountDao.findAllAccount();
        for (Account account:accounts
             ) {
            System.out.println(account);
        }
    }
}

</ pre>

Die Ergebnisse sind wie folgt:

Account{id=1, name='赵敏', money=99999.99}
Account{id=2, name='张无忌', money=11111.1}
Account{id=3, name='木婉清', money=22222.22}

</ pre>

Alle Konten wurden erfolgreich abgefragt, was darauf hinweist, dass die Abhängigkeitsinjektion über den Container erreicht werden kann, was darauf hinweist, dass sowohl Spring als auch Mybatis erfolgreich konfiguriert und erfolgreich integriert wurden.

PS: Hier verwendet Spring @RunWith und @ContextConfiguration, um junit zu integrieren

springMVC Konfiguration

1. Konfigurieren Sie web.xml

Das SpringMVC-Framework basiert auf DispatcherServlet, mit dem alle HTTP-Anforderungen und -Antworten verarbeitet werden. Daher müssen wir die Datei web.xml so konfigurieren, dass die Anforderungen zugeordnet werden, die DispatcherServlet verarbeiten soll.

<servlet>
    <servlet-name>demo</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springMVC.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>demo</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

</ pre>

Natürlich müssen Sie das Servlet und die Servlet-Zuordnung konfigurieren.

Mit der Konfiguration <init-param> können wir die Servlet-Konfigurationsdatei während der Initialisierung laden.

2. Setzen Sie die Feder MVC.xml ein

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置创建 springMVC要扫描的包 -->
    <context:component-scan base-package="com.hust">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 开启SpringMVC框架注解的支持 -->
    <mvc:annotation-driven/>
</beans>

</ pre>

3. Schreiben Sie die AccountController-Klasse

@Controller
@RequestMapping("/account")
public class AccountController {
    @Autowired
    private IAccountService accountService;

    @RequestMapping("/all")
    public String findAllAccounts(){
        return "success";
    }
}

</ pre>

Zu diesem Zeitpunkt wurde springMVC konfiguriert, wir starten den Server und wenn wir nach dem Zugriff auf den Pfad / account / all zur Seite success.jsp springen, wird das folgende Bild angezeigt.

Bild

Es zeigt, dass die springMVC-Konfiguration erfolgreich ist

Feder integriert springMVC

Denkanalyse

Wenn der Server zu diesem Zeitpunkt gestartet wird, wird die Datei applicationContext.xml nicht geladen, und das Spring-Framework spielt keine Rolle. Daher ist es unmöglich, die Abhängigkeitsinjektion über die Annotation @AutoWire zu implementieren und die Methode der Serviceschicht aufzurufen. Daher besteht unsere Idee darin, die Konfigurationsdatei zu laden und den Container beim Start des Servers zu erstellen. Auf diese Weise kann die Präsentationsschicht die Geschäftsschichtmethoden aufrufen.

Implementierung

Wir stellen den Listener so ein, dass nach dem Start des Servers die Konfigurationsdatei geladen und der Container initialisiert wird.

Die endgültige Datei web.xml lautet wie folgt:

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>Archetype Created Web Application</display-name>

    <!-- 配置spring提供的监听器，用于启动服务时加载容器。
    该监听器会加载WEB-INF目录中名称为applicationContext.xml的配置文件-->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <!-- 指定spring配置文件的位置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <servlet>
        <servlet-name>demo</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMVC.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>demo</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

</ pre>

Ändern Sie gleichzeitig die AccountController-Klasse

@Controller
@RequestMapping("/account")
public class AccountController {
    @Autowired
    private IAccountService accountService;

    @RequestMapping("/all")
    public String findAllAccounts(){
        List<Account> all = accountService.findAllAccount();
        for (Account a:all
             ) {
            System.out.println(a);
        }
        return "success";
    }
}

</ pre>

Beim Zugriff auf die Seite success.jsp wird das Backend ausgegeben

Account{id=1, name='赵敏', money=99999.99}
Account{id=2, name='张无忌', money=11111.1}
Account{id=3, name='木婉清', money=22222.22}

</ pre>

Es zeigt, dass das accountService-Objekt durch den Container injiziert werden kann und die Integration erfolgreich ist.

PS: Verwenden Sie die Annotation @RestController, um die API zu realisieren und den Effekt der Trennung von Vorder- und Rückseite zu erzielen.

Zusammenfassung

Der entscheidende Punkt ist hauptsächlich, wie das Federgerüst zur Integration anderer Gerüste verwendet werden kann. Unter diesen ist das Verständnis der Rolle des Federgerüsts sehr wichtig!

Wenn Sie Fragen haben oder etwas falsch schreiben, hinterlassen Sie bitte eine Nachricht zur Diskussion!

Unterschiedliche Ideen, dies ist die prägnanteste und klarste SSM-Framework-Integration, die ich je gesehen habe

Erstellen Sie Ideen für die Integration von Projekten und SSM-Frameworks

Mybatis-Konfiguration

Federkonfiguration und Integration von Mybatis

Zweitens integriert Spring Mybatis

springMVC Konfiguration

Feder integriert springMVC

Zusammenfassung

Ich denke du magst