English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

  1. Standort
  2. Startseite
  3. Erfahrungshinweise
  4. Inhaltsverzeichnis

Beispielcode zur Integration des SSM-Frameworks auf Basis von Maven

Basisbegriffe

1.1und Spring

Spring ist ein Open-Source-Framework und wurde im Jahr2003 Eine leichte Java-Entwicklungsrahmenarbeit, die 2002 entstand und von Rod Johnson in seinem Werk "Expert One" beschrieben wurde.-On-One J2Die im EE Development and Design dargestellten Ideen und Prototypen sind die Grundlage. Es wurde geschaffen, um die Komplexität der Entwicklung von Unternehmensanwendungen zu lösen. Spring nutzt grundlegende JavaBeans, um Dinge zu tun, die früher nur durch EJB möglich waren. Allerdings ist der Anwendungsbereich von Spring nicht nur auf die Entwicklung im Serverumfeld beschränkt. In Bezug auf Einfachheit, Testbarkeit und lose Kopplung kann jede Java-Anwendung von Spring profitieren. Kurz gesagt, Spring ist ein leichtgewichtiger Container-Framework für Inversion of Control (IoC) und Aspect-Oriented Programming (AOP).

1.2,SpringMVC

Spring MVC ist ein Nachfolgerprodukt von SpringFrameWork und ist in Spring Web Flow integriert. Spring MVC trennt die Rollen von Controller, Model-Objekten, Dispatchern und Handler-Objekten, was es einfacher macht, sie anzupassen.

1.3,

,MyBatis 2010MyBatis war ursprünglich ein Open-Source-Projekt von Apache, iBatis,

Schritt 1: Dieser Projekt wurde von der Apache Software Foundation auf Google Code migriert und in MyBatis umbenannt. MyBatis ist eine auf Java basierende Datenbank-Persistence-Layer-Framework. Das Persistence-Layer-Framework von iBATIS umfasst SQL Maps und Data Access Objects (DAO). MyBatis beseitigt fast alle JDBC-Code und manuelle Einstellungen von Parametern sowie die Suche nach Result-Sets. MyBatis verwendet einfache XML oder Annotierungen zur Konfiguration und Mapping, um Schnittstellen und Java-POJOs (Plain Old Java Objects, einfache Java-Objekte) in Datenbank-Records zu映射en.Durch Maven ein Web-Projekt erstellen.

Schritt 2:pom-Datei Import von JAR-Paketen

(1) pom.xml

Ich habe meine gesamte pom-Datei kopiert, einige initial vorhandene Elemente müssen entfernt werden, um nur die von Ihrer pom-Datei generierte Version zu behalten.

<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/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>com.test</groupId>
 <artifactId>ssm</artifactId>
 <packaging>war</packaging>
 <version>0.0.1-SNAPSHOT</version>
 <name>ssm Maven Webapp</name>
 <url>http://maven.apache.org</url>
 <properties> 
  <!-- Spring-Version --> 
  <spring.version>4.0.2.RELEASE</spring.version> 
  <!-- MyBatis-Version --> 
  <mybatis.version>3.2.6</mybatis.version> 
  <!-- log4Version der j-Protokollierungsdateiverwaltungspakets --> 
  <slf4j.version>1.7.7</slf4j.version> 
  <log4j.version>1.2.17</log4j.version> 
 </properties> 
 <dependencies>
 <dependency>
  <groupId>junit/groupId>
  <artifactId>junit/artifactId>
  <version>3.8.1</version>
  <scope>test/scope>
 </dependency>
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-core/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-oxm/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>org.springframework/groupId> 
   <artifactId>spring-webmvc/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-aop/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-context-support/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <dependency> 
   <groupId>org.springframework/groupId> 
   <artifactId>spring-test/artifactId> 
   <version>${spring.version}/version> 
  </dependency> 
  <!-- MyBatis-Kernpaket --> 
  <dependency> 
   <groupId>org.mybatis/groupId> 
   <artifactId>mybatis/artifactId> 
   <version>${mybatis.version}/version> 
  </dependency> 
  <!-- mybatis/Spring-Paket --> 
  <dependency> 
   <groupId>org.mybatis/groupId> 
   <artifactId>mybatis-spring/artifactId> 
   <version>1.2.2</version> 
  </dependency> 
  <!-- Importieren Sie das java ee JAR-Paket --> 
  <dependency> 
   <groupId>javax/groupId> 
   <artifactId>javaee-api/artifactId> 
   <version>7.0</version> 
  </dependency> 
  <!-- Importieren Sie das JAR-Paket für die MySQL-Datenbankverbindung --> 
  <dependency> 
   <groupId>mysql/groupId> 
   <artifactId>mysql-connector-java/artifactId> 
   <version>5.1.30</version> 
  </dependency> 
  <!-- Importieren Sie das dbcp-JAR-Paket, um die Datenbank in applicationContext.xml zu konfigurieren --> 
  <dependency> 
   <groupId>commons-dbcp/groupId> 
   <artifactId>commons-dbcp/artifactId> 
   <version>1.2.2</version> 
  </dependency> 
  <!-- JSTL-Tag-Klassen --> 
  <dependency> 
   <groupId>jstl/groupId> 
   <artifactId>jstl/artifactId> 
   <version>1.2</version> 
  </dependency> 
  <!-- Protokollierungsdateiverwaltungspaket --> 
  <!-- log start --> 
  <dependency> 
   <groupId>log4j</groupId> 
   <artifactId>log4j</artifactId> 
   <version>${log4j.version</version> 
  </dependency> 
  <!-- Objekte formatieren, um die Protokollierung zu erleichtern --> 
  <dependency> 
   <groupId>com.alibaba/groupId> 
   <artifactId>fastjson/artifactId> 
   <version>1.1.41</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 --> 
  <!-- JSON-Einlesen --> 
  <dependency> 
   <groupId>org.codehaus.jackson/groupId> 
   <artifactId>jackson-mapper-asl</artifactId> 
   <version>1.9.13</version> 
  </dependency> 
  <!-- Upload-Komponentenpaket --> 
  <dependency> 
   <groupId>commons-fileupload</groupId> 
   <artifactId>commons-fileupload</artifactId> 
   <version>1.3.1</version> 
  </dependency> 
  <dependency> 
   <groupId>commons-io</groupId> 
   <artifactId>commons-io</artifactId> 
   <version>2.4</version> 
  </dependency> 
  <dependency> 
   <groupId>commons-codec</groupId> 
   <artifactId>commons-codec</artifactId> 
   <version>1.9</version> 
  </dependency> 
 </dependencies>
 <build>
 <finalName>ssm</finalName>
 </build>
</project>

第三步：看整体的项目架构，先说明下我这里还没有有关springMVC的相关东西，因为我先整合sping-mybatis,在测试是否成功，成功在整合springMVC

第四步：建立model类

public class User {
 private int id;
 private String name;
 private String password;
 private String password2; 
/*提供set和get方法，toString方法*/
}

Schritt 5:创建数据库,UserDao接口和mapper映射文件

（1）建立很简单的一张表

（2）UserDao接口

public interface UserDao {
  User findUserById(User user);
}

（3）UesrMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace命名空间，指向UserDao全路径-->
<mapper namespace="com.ssm.dao.UserDao">
 <!-- 根据id查询用户信息 -->
 <!-- 
  id：唯一标识一个statement，和UserDao方法名一致
  #{}：表示一个占位符，如果#{}中传入简单类型的参数，#{}中的名称随意
  parameterType：输入参数的类型，和UserDao()里参数一致
  resultType：输出结果类型，和UserDao()返回类型一致
  -->
 <select id="findUserById" parameterType="com.ssm.model.User" resultType="com.ssm.model.User">
  SELECT * FROM USER 
  <where>
  <if test="name != null">
   UND Name= #{name}
  </if>
  <if test="password != null">
   UND password= #{password}
  </if>
  </where> 
 </select>
 </mapper>

Schritt 5:Erstellen Sie UserService und UserServerImpl

（1）UserService

public interface UserService {
  public User getUserById(User user); 
}

（2）UserServiceImpl

import org.springframework.stereotype.Service;
import com.ssm.dao.UserDao;
import com.ssm.model.User;
import com.ssm.service.UserService;
@Service("userService")
public class UserServerImpl implements UserService {
 @Resource
 private UserDao userDao;
 public User getUserById(User user) {
  return this.userDao.findUserById(user);
 }
}

Schritt 6:Erstellen Sie die Dateien jdbc und log

（1）jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc\:mysql\://localhost\:3306/test?useUnicode=true&&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root

（2）log4j.properties

log4j.rootLogger=INFO,Console,File 
#Die Logausgabeziel wird auf die Konsole definiert 
log4j.appender.Console=org.apache.log4j.ConsoleAppender 
log4j.appender.Console.Target=System.out 
Die Logausgabeformat kann flexibel angegeben werden. Das nächste Zeile spezifiziert das konkrete Format 
log4j.appender.Console.layout = org.apache.log4j.PatternLayout 
log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n 
#Wird eine neue Datei erstellt, wenn die Dateigröße den angegebenen Wert erreicht 
log4j.appender.File = org.apache.log4j.RollingFileAppender 
#Bestimmt das Ausgabeverzeichnis 
log4j.appender.File.File = logs/ssm.log 
#Definiert die maximale Dateigröße 
log4j.appender.File.MaxFileSize = 10MB 
# Alle Protokolle ausgeben, wenn auf DEBUG geändert wird, wird DEBUG und höherer Protokollebene ausgegeben 
log4j.appender.File.Threshold = ALL 
log4j.appender.File.layout = org.apache.log4j.PatternLayout 
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH:mm:ss}][%c]%m%n

Schritt 7:Integration von Spring-mybatis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 
 xmlns:context="http://www.springframework.org/schema/context" 
 xmlns:mvc="http://www.springframework.org/schema/mvc" 
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
      http://www.springframework.org/schema/context 
      http://www.springframework.org/schema/context/spring-context-3.1.xsd 
      http://www.springframework.org/schema/mvc 
      http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd"> 
 <!-- Automatische Scannung --> 
 <context:component-scan base-package="com.ssm" /> 
 <!-- Einführung der jdbc-Konfigurationsdatei --> 
 <bean id="propertyConfigurer" 
  class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
  <property name="location" value="classpath:jdbc.properties" /> 
 </bean> 
 <!-- 2. Datenbankverbindungspool -->
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
  destroy-method="close"> 
  <property name="driverClassName" value="${jdbc.driver}" /> 
  <property name="url" value="${jdbc.url}" /> 
  <property name="username" value="${jdbc.username}" /> 
  <property name="password" value="${jdbc.password}" /> 
 </bean> 
  <!-- Spring und MyBatis Integration, die durch Spring die SqlSessionFactory-Sitzungsfabrik von MyBatis verwalten -->
 <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> 
  <!-- Beziehen Sie die Datenbankverbindungspool-Referenz -->
  <property name="dataSource" ref="dataSource" /> 
  <!-- Scannen der mapping.xml-Dateien automatisch --> 
  <property name="mapperLocations" value="classpath:com/ssm/mapper/*.xml"></property> 
 </bean> 
 <!-- Paketname der DAO-Schnittstellen, Spring sucht automatisch nach den Klassen darunter --> 
 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> 
  <property name="basePackage" value="com.ssm.dao" /> 
  <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property> 
 </bean> 
 <!-- (Transaktionsmanagement) Transaktionsmanager, verwenden Sie JtaTransactionManager für globale Transaktionen --> 
 <bean id="transactionManager" 
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
  <property name="dataSource" ref="dataSource" /> 
 </bean> 
</beans>

Schritt 8:Testklasse erstellen

Nach diesen Schritten (log4j nicht konfiguriert hat, beeinflusst dies nichts），haben wir die Integration von Spring und mybatis abgeschlossen und können daher ein Testcode schreiben, um zu überprüfen, ob dies erfolgreich war.

Testklasse im src/test/in Java erstellt, bedeutet dies, dass Spring und Mybatis erfolgreich integriert wurden, wenn der Test erfolgreich ist. Die ausgegebenen Informationen verwenden Log4j auf die Konsole ausgeben.

（1）TestMyBatis测试类

package ssm;
import javax.annotation.Resource;
import org.apache.log4j.Logger;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.ssm.model.User;
import com.ssm.service.UserService;
/*lässt den Test in der Spring-Testumgebung laufen*/
@RunWith(SpringJUnit4ClassRunner.class) 
/*um den Ort der zu ladenden Spring-Konfigurationsdatei zu bestimmen, wird die Standardkonfigurationsdatei geladen*/
@ContextConfiguration(locations = { "classpath:spring-mybatis.xml" })
public class TestMyBatis {
 @Resource(name = "userService") 
 private UserService userService;
 @Test
 public void test1() {
  User user=new User();
  user.setName("张三");
  user.setPassword("123");
  User user1 = userService.getUserById(user);
  System.out.println(user1.toString());
 }
}

Am Ende! Der Schlüssel liegt in der Ausgabe des Backends, es ist auch die Zeit, ein Wunder zu beweisen, wenn ein Objekt ausgegeben wird, bedeutet das, dass Sie erfolgreich integriert haben!

Dann beginnen wir mit der Integration von SpringMVC

Schritt 9:konfigurieren Sie springmvc.xml

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 
 xmlns:context="http://www.springframework.org/schema/context" 
 xmlns:mvc="http://www.springframework.org/schema/mvc" 
 xsi:schemaLocation="http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
      http://www.springframework.org/schema/context 
      http://www.springframework.org/schema/context/spring-context-3.1.xsd 
      http://www.springframework.org/schema/mvc 
      http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd"> 
 <!-- automatisch das Paket scannen, damit SpringMVC annimmt, dass die Klassen unter diesem Paket, die die @controller-Annotation verwenden, Controller sind --> 
 <context:component-scan base-package="com.ssm.controller" /> 
 <!--Vermeiden Sie, dass IE beim Ausführen von AJAX, wenn JSON zurückgegeben wird, die Datei herunterlädt --> 
 <bean id="mappingJacksonHttpMessageConverter" 
  class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"> 
  <property name="supportedMediaTypes"> 
   <list> 
    <value>text/html;charset=UTF-8</value> 
   </list> 
  </property> 
 </bean> 
 <!-- Aktivierung der Annotierungsfunktion von SpringMVC, um die Abbildung von Anfragen und Annotierung POJO abzuschließen --> 
 <bean 
  class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"> 
  <property name="messageConverters"> 
   <list> 
    <ref bean="mappingJacksonHttpMessageConverter" /> <!-- JSON-Converter --> 
   </list> 
  </property> 
 </bean> 
 <!-- Definition der Prä- und Suffixe für die zu wechselnden Dateien, Konfiguration der Ansichtsmuster--> 
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
  <!-- Meine Interpretation dieser Konfiguration ist, dass die Methodenreturn-Strings der nachfolgenden action automatisch mit einem Präfix und einem Suffix versehen werden, um eine nutzbare URL-Adresse zu erstellen --> 
  <property name="prefix" value="/WEB-INF/jsp/" /> 
  <property name="suffix" value=".jsp" /> 
 </bean> 
 <!-- Konfiguration der Datei-Upload, falls keine Datei-Upload verwendet wird, ist keine Konfiguration erforderlich, natürlich nicht, wenn nicht konfiguriert, dann ist auch keine Upload-Komponenten-Pakete im Konfigurationsdatei erforderlich --> 
 <bean id="multipartResolver" 
  class="org.springframework.web.multipart.commons.CommonsMultipartResolver"> 
  <!-- Standardkodierung --> 
  <property name="defaultEncoding" value="utf-8" /> 
  <!-- Maximaler Dateigröße --> 
  <property name="maxUploadSize" value="10485760000" /> 
  <!-- Maximaler Wert im Speicher --> 
  <property name="maxInMemorySize" value="}}40960" /> 
 </bean> 
</beans>

Zehnter Schritt:die web.xml-Datei konfiguriert

hier wird spring-der Eintrag und die Konfiguration von mybatis.xml sowie von spring-Der Servlet von MVC dient dazu, die Integration von SSM abzuschließen, zuvor2Für die Integration des Frameworks ist hier keine Konfiguration erforderlich.

<?xml version="1.0" encoding="UTF-8"?> 
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
 xmlns="http://java.sun.com/xml/ns/javaee" 
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" 
 version="3.0"> 
 <display-name>Archetype Created Web Application</display-name> 
 <!-- Konfigurationsdateien von Spring und MyBatis --> 
 <context-param> 
  <param-name>contextConfigLocation</param-name> 
  <param-value>classpath:spring-mybatis.xml</param-value> 
 </context-param> 
 <!-- Kodierungsfilter --> 
 <filter> 
  <filter-name>encodingFilter</filter-name> 
  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> 
  <async-supported>true</async-supported> 
  <init>-param> 
   <param-name>encoding</param-name> 
   <param-value>UTF-8</param-value> 
  </init-param> 
 </filter> 
 <filter-mapping> 
  <filter-name>encodingFilter</filter-name> 
  <url-pattern>/*</url-pattern> 
 </filter-mapping> 
 <!-- Spring Listener --> 
 <listener 
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
 </listener> 
 <!-- Vermeidung des Spring-Memory-Überflusses Listener --> 
 <listener 
  <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class> 
 </listener> 
 <!-- Spring MVC Servlet --> 
 <servlet> 
  <servlet-name>SpringMVC</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> 
  <async-supported>true</async-supported> 
 </servlet> 
 <servlet-mapping> 
  <servlet-name>SpringMVC</servlet-name> 
  <!-- Hier kann es konfiguriert werden*.do, entsprechend derSuffixkonvention von Struts --> 
  <url-pattern>/</url-pattern> 
 </servlet-mapping> 
 <welcome-file-list> 
  <welcome-file>/index.jsp</welcome-file> 
 </welcome-file-list> 
</web-app>

Zehnter SchrittLetzter Test:

(1) Zuerst schreiben Sie login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
 pageEncoding="UTF-8"%>
<html>
<head>
<title>Benutzeranmeldung：</title>
</head>
<body>
<form action="login">
<label>Benutzername：</label>
<input type="text" id="username" name="username"></input><br><br>
<label>Passwort：</label>
<input type="text" id="password" name="password"></input><br><br>
<input type="submit" value="Anmelden">/>
</form>
</body>
</html>

Oberfläche:

(2) bei der Erstellung von UserController

import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.ssm.dao.UserDao;
import com.ssm.model.User;
@Controller
public class UserController {
 @Resource
 private UserDao userDao;  
@RequestMapping("/jsp/login") 
public String login(HttpServletRequest request){
 String username=request.getParameter("username");
 String password=request.getParameter("password");
 User user=new User();
 //Suchen Sie nach dem Benutzername und dem Studenten in der Datenbank
 user.setName(username);
 user.setPassword(password);
  User users=userDao.findUserById(user);
 //Es gibt Studenten, das bedeutet, dass die Anmeldung erfolgreich war
 if(users!=null){
  return "susscss";
 }
 //Dieses jsp habe ich nicht geschrieben, das ist okay, Sie wissen es einfach, Sie können es selbst schreiben
 return "err";
} 
}

(3)Letztes susscss.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
 pageEncoding="UTF-8"%>
<html>
<body>
<P>Benutzername und Passwort sind korrekt, Anmeldeerfolg</P>
</body>
</html>

Perfekt!

Das ist der gesamte Inhalt dieses Artikels. Wir hoffen, dass er Ihnen bei Ihrem Lernen hilft und wir hoffen, dass Sie die Anleitung von Rufen stark unterstützen.

Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem Urheberrechtlichem Inhaber. Der Inhalt wurde von Internetbenutzern freiwillig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht von Hand bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Wenn Sie urheberrechtlich beanstandete Inhalte finden, sind Sie herzlich eingeladen, eine E-Mail an notice#w zu senden.3codebox.com (Bitte ersetzen Sie # durch @ beim Senden einer E-Mail zur Meldung von Missbrauch und stellen Sie relevante Beweise zur Verfügung. Sobald nachgewiesen, wird diese Website die beanstandeten urheberrechtlichen Inhalte sofort löschen.

Grundlagen-Tutorial
Vielleicht gefällt dir auch