Explication graphique détaillée des bases du projet Web Java

1. Structure du module Web Java

Les fichiers JSP sont similaires aux fichiers AXPX, et les chemins et URL correspondent un à un sera compilé dynamiquement dans une classe distincte. Le cœur de Java Web et d'ASP.NET sont respectivement les interfaces Servlet et IHttpHandler. Par conséquent, la méthode de base du fichier Page (JSP, ASPX) et la méthode MVC développée ultérieurement (Spring MVC, ASP.NET MVC) sont basées sur le noyau. interface. Fondamentalement, encapsuler et étendre à nouveau (DispatcherServlet, MvcHandler). (Recommandé : Tutoriel vidéo Java)

À l'exception des fichiers JSP, tous les autres fichiers sont déployés dans le sous-répertoire WEB-INF du répertoire de l'application. Le répertoire WEB-INF peut être considéré comme ASP. .NET Stockez le fichier web.config, le répertoire bin et le répertoire d'exécution commençant par App_ dans un répertoire racine unifié.

Le fichier de configuration web.xml de Java Web est également stocké dans le répertoire WEB-INF, tandis que le fichier de configuration web.config d'ASP.NET est généralement stocké directement dans le répertoire de l'application (d'autres répertoires ASP.NET peuvent également avoir des fichiers web. .config). ASP.NET déploie toutes les références et les DLL générées par le code dans bin, tandis que les fichiers jar de référence et les classes générées de Java Web sont stockés respectivement dans les sous-répertoires lib et classes de WEB-INF (référence 1).

Pour résumer, similaire à web.config, bin, App_Data, etc. dans ASP.NET, WEB-INF, web.xml, lib et classes dans Java Web sont ce que nous devons comprendre et maîtriser.

|--Assembly Root
  |---WEB-INF/
    |--web.xml
    |--lib/
    |--classes/

1. Répertoire WEB-INF : le répertoire racine des fichiers Web Java.

2. Fichier web.xml : fichier de configuration (asp.net web.config).

3. répertoire lib : stocke les fichiers de la bibliothèque de classes (asp.net bin).

4. Répertoire des classes : stocke les fichiers de classe (asp.net bin).

2. La structure de base du projet Web Java [Projet Web dynamique Eclipse]

Projet Web dynamique Eclipse

( 1) Vous pouvez configurer le répertoire de code source et le répertoire de sortie qui doivent être compilés. Par défaut, les fichiers sources du répertoire src sont compilés dans le répertoire buildclasses.

(2) Vous pouvez configurer le répertoire racine de WEB-INF, qui est par défaut WebContent.

(3) Vous pouvez choisir de générer ou non un fichier web.xml par défaut.

Nous créons un projet Dynamic Web Proejct nommé DynamicWP qui génère web.xml par défaut. La structure du fichier est la suivante :

|--DynamicWP
  |--.settings/
  |--build/
    |--classes/
  |--src/
  |--WebContent/
    |--META-INF/
      |--MANIFEST.MF
    |--WEB-INF/
      |--web.xml
      |--lib/

La vue du projet DyanmicWP dans l'explorateur de projet Eclipse est la suivante :

|--DynamicWP
  |--Deployment Desciptor
  |--JAX-WS Web Services
  |--Java Resources
  |--JavaScript Resources
  |--build
  |--WebContent
    |--META-INF/
      |--MANIFEST.MF
    |--WEB-INF/
      |--web.xml
      |--lib/

1 .settings est le dossier du projet Eclipse, qui stocke diverses configurations. du projet Eslipse. Non visible dans la vue du projet Eclipse.

2. Le répertoire src stocke le code source. Dans la vue projet d'Eclipse, cela correspond à Java Resources/src.

3. Construisez les fichiers compilés des magasins.

4. Vous pouvez afficher la structure des fichiers d'exécution dans un répertoire workspace.metadata.pluginsorg.eclipse.wst.server.coretmp1wtpwebappsDynamicWP similaire.

3. Structure de base du projet Web Maven

Compte tenu du fait qu'il existe de nombreux IDE Java et qu'ils ont tous un certain degré de support, projet Web Java d'Eclipse Non portable. Maven résout non seulement le problème de spécification de la structure du projet, mais fournit également des fonctions puissantes telles qu'un puissant traitement de référence. Il est devenu le standard de facto actuel en termes de présentation de projet et d'autres aspects. La structure principale du projet Maven est la suivante (référence 2) :

|--root
  |--pom.xml
  |--src/
    |--main/
      |--java/
      |--resources/
      |--webapp/
    |--test/
      |--java/
      |--resources
  |--target/

Créez un nouveau projet d'application Web Maven dans Eclipse. La structure du fichier est la suivante :

|--MavenWP
  |--pom.xml
  |--.project
  |--.classpath
  |--.settings/
  |--src/
  |--target/
    |--classes/
    |--m2e-wtp/

1. pom.xml : fichier de configuration du projet maven.

2. Le fichier .project et le fichier .classpath ainsi que les fichiers du répertoire .settings et du répertoire target/m2e-wtp sont des fichiers de configuration du projet Eclipse.

3. src et target : répertoire de projet standard maven.

La vue de gestion des ressources du projet correspondante dans Eclipse4.5.1

|--MavenWP
  |--Deployment Desciptor/
  |--Java Resources/
  |--JavaScript Resources/
  |--Deployed Resources/
  |--src
  |--target
  |--pom.xml

1 Le projet créé ajoutera un index.jsp et signalera une erreur : utilisez maven pour rechercher et ajouter des dépendances de servlet, puis. ce sera une course normale.

2. Avertissement de problème de chemin de construction Java : utilisez maven pour rechercher et ajouter le plug-in du compilateur et configurer la mise à jour du nœud de configuration pour l'éliminer.

3. Pour configurer l'image maven pour le problème du mur, j'utilise http://maven.oschina.net/content/groups/public/.

4. Les répertoires tels que src/main/java, src/test/java et src/test/resources qui manquent dans l'application Web maven créée par défaut doivent être ajoutés manuellement.

5. Modifiez .settings/org.eclipse.wst.common.project.facet.core.xml et mettez à jour.

6. Le début du nœud racine web.xml est modifié comme suit :

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">

Fichier de configuration de Maven pom.xml :

<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>me.test</groupId>
    <artifactId>MavenWP</artifactId>
    <packaging>war</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>MavenWP Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>MavenWP</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

4. . Bases du servlet

Tout comme le cœur d'ASP.NET est IHttpHandler, le cœur de Java Web est l'interface Servlet, située dans l'espace de noms javax.servlet. Pour le concept de filtre, vous pouvez vous référer au HttpModule d'ASP.NET. Pour divers écouteurs dans les servlets, vous pouvez vous référer à des événements similaires dans ASP.NET HttpApplicaiton.

Qu'il s'agisse de la technologie Web Java ou .NET, elles reposent toutes sur l'implémentation spécifique du protocole HTTP. Certains éléments de base de Java Web et ASP.NET correspondent comme suit :

Schéma simplifié de Servlet et ASP.NET :

用于简化web.xml配置的Servlet的注解（3.0开始支持，在ASP.NET中没有对应项）：

（1）WebServlet：作用在javax.servlet.http.HttpServlet的实现类上。

（2）WebFilter：作用在javax.servlet.Filter的实现类上。

（3）WebListener：作用在Listener的实现类上（javax.servlet.ServletContextListener、javax.servlet.ServletContextAttributeListener、javax.servlet.ServletRequestListener、javax.servlet.ServletRequestAttributeListener、javax.servlet.http.HttpSessionListener、javax.servlet.http.HttpSessionAttributeListener）。

（4）WebInitParam：结合WebServlet和WebFilter注解用来配置属性。

（5）MultipartConfig：作用在javax.servlet.http.HttpServlet的实现类上。标注请求是mime/multipart类型。

用于Servlet容器初始化的ServletContainerInitializer（可实现无web.xml，3.0开始支持，可类比ASP.NET的Application_Start方法）：

（1）Servlet容器启动时查找ServletContainerInitializer的实例。

（2）ServletContainerInitializer实例使用HandlesTypes标注一个或多个类型，Servlet容器将在启动时扫描classpath，获取这些类型的实例。

（3）Servlet容器在启动时调用ServletContainerInitializer实现类的onStartup方法，该方法可以获取HandlesTypes标注的所有类型对象。

五、自定义Session

Session在存储安全性要求较高的会话信息方面是必不可少的，Session当然绝对不是用来存储用户登录状态的，但类似验证码等敏感信息却必须存储在Session中。对于分布式Web应用自定义Session支持独立的状态服务器或集群是必须的。

ASP.NET通过SessionStateModule通过配置文件配置实际的Session提供程序，Session提供程序实现了SessionStateStoreProviderBase，因此在ASP.NET中实现自定义Session是通过继承SessionStateStoreProviderBase实现，配置Session是通过Web.config。

同理，Java Servlet中使用自定义Session通过Filter可以实现。由于不同的servlet容器对Session的实现不同，所以通用性最好的方式是继承HttpServletRequestWrapper重写getSession方法返回自定义的Session对象。

（1）首先自定义继承HttpSession的MySession（为了便于演示，仅包装了容器的session并转发调用）。

import java.util.Enumeration;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;

public class MySession implements HttpSession {

    private HttpSession _containerSession;

    public MySession(HttpSession session) {
        this._containerSession = session;
    }

    @Override
    public long getCreationTime() {
        return this._containerSession.getCreationTime();
    }

    @Override
    public String getId() {
        return this._containerSession.getId();
    }

    @Override
    public long getLastAccessedTime() {
        return this._containerSession.getLastAccessedTime();
    }

    @Override
    public ServletContext getServletContext() {
        return this._containerSession.getServletContext();
    }

    @Override
    public void setMaxInactiveInterval(int interval) {
        this._containerSession.setMaxInactiveInterval(interval);
    }

    @Override
    public int getMaxInactiveInterval() {
        return this._containerSession.getMaxInactiveInterval();
    }

    @SuppressWarnings("deprecation")
    @Override
    public HttpSessionContext getSessionContext() {
        return this._containerSession.getSessionContext();
    }

    @Override
    public Object getAttribute(String name) {
        return this._containerSession.getAttribute(name);
    }

    @SuppressWarnings("deprecation")
    @Override
    public Object getValue(String name) {
        return this._containerSession.getValue(name);
    }

    @Override
    public Enumeration<String> getAttributeNames() {
        return this._containerSession.getAttributeNames();
    }

    @SuppressWarnings("deprecation")
    @Override
    public String[] getValueNames() {
        return this._containerSession.getValueNames();
    }

    @Override
    public void setAttribute(String name, Object value) {
        this._containerSession.setAttribute(name, value);
    }

    @SuppressWarnings("deprecation")
    @Override
    public void putValue(String name, Object value) {
        this._containerSession.putValue(name, value);
    }

    @Override
    public void removeAttribute(String name) {
        this._containerSession.removeAttribute(name);
    }

    @SuppressWarnings("deprecation")
    @Override
    public void removeValue(String name) {
        this._containerSession.removeValue(name);
    }

    @Override
    public void invalidate() {
        this._containerSession.invalidate();
    }

    @Override
    public boolean isNew() {
        return this._containerSession.isNew();
    }

}

（2）自定义继承HttpServletRequestWrapper的MyRequest

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpSession;

public class MyRequest extends HttpServletRequestWrapper {

    public MyRequest() {
        super(null);
    }

    public MyRequest(HttpServletRequest request) {
        super(request);
        // TODO 自动生成的构造函数存根
    }

    @Override
    public HttpSession getSession(boolean create) {
        return new MySession(super.getSession(create));
    }

    @Override
    public HttpSession getSession() {
        return new MySession(super.getSession());
    }
}

（3）自定义Filter将Request包装为MyRequest

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;

@WebFilter("/*")
public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // TODO 自动生成的方法存根

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        chain.doFilter(new MyRequest((HttpServletRequest) request), response);

    }

    @Override
    public void destroy() {
        // TODO 自动生成的方法存根

    }

}

通过注解配置了Filter，也可以通过原始的web.xml方式配置。

小结：

你至少应该知道的：

（1）配置文件：ASP.NET的web.config和Java的web.xml

（2）Web核心：ASP.NET的IHttpHandler接口和Java的Servlet接口

（3）拦截器：ASP.NET的HttpModule和Java的Filter

（4）应用程序事件：ASP.NET的HttpApplication event和Java的各种Listener

（5）启动器：ASP.NET的Application_Start和Java的ServletContainerInitializer

（6）引用管理：ASP.NET的Nuget和Java的Maven

感想：

ASP.NET的核心对象不像Java Servlet一样，从一开始就基于接口，这是缺点。但Java Servlet的核心对象全靠容器实现，就连HttpSession同样如此，这也是缺点。比如自定义个Session十分麻烦，没有像ASP.NET一样简单配置即可。另外Servlet的一些抽象定义有点过头了，不够简洁。

更多java知识请关注java基础教程栏目。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!