个人通讯录JAVA程序代码 javaweb个人通讯录

转载

mob64ca1409d8ea 2024-07-22 16:37:12

文章标签 个人通讯录JAVA程序代码 xml spring Java 文章分类 Java 后端开发

部分参考：Heart First Java Web（教程）

一、实现基础

1.底层逻辑——交互

JavaWeb的底层逻辑就是交互，实现以下功能：

从客户端（浏览器）发送http相关的请求行（header等resquest），发送到网络服务器（Servers，比如tomcat服务器），然后服务器找到请求对应的返回值（request->respond），继而通过网络发送到客户端（浏览器）展示。

2.底层环境-Servlet

这中间用到的规则，也就是底层环境是Servlet，其包括初始化、交互等接口规则，由于使用起来需要写很多具体的方法来实现抽象的接口，实际应用起来非常麻烦。

有时候按教程写完代码，也会报很多错误，核心原因是javax.servlet这个包找不到。前面提的过 Servlet API 是包含在 JavaEE 当中的。为了方便，我们可以直接使用 Tomcat 附带的 servlet-api.jar 包。

因而懒惰的程序员想着封装一个常用的经典的东西来实现Servlet，于是HttpServlet作为Servlet接口的具体实现方法出现了。它的使用及其简单，只要重写其中一个交互式方法即可，意思就是你需要返回什么内容，直接写出来，它就给你返回了。

其他部分比如初始化等内容，它都预先给你设置成默认值了。

这里Sevrlet模式下的基本目录结构如下：

webapps
  - MyFirstServlet
    - WEB-INF
      - classes
        - com
          - skyline
            - MyFirstServlet.class
    - web.xml

3.Servlet之上的抽象接口-JSP

直接使用 Servlet 生成网页，不仅代码写起来困难，可维护性也不高。为了把 HTML 这些非逻辑的部分抽离出来，人们引入了 JSP 技术。

JSP，全称 JavaServer Pages。可以把 JSP 理解成一种高度抽象的 Servlet。事实上 JSP 在运行期间会被编译成 Servlet，因此 JSP 和 Servlet 可以认为没有本质上的差异，只不过写起来容易了很多。

现在流行的 Web 服务架构往往采用前后端分离的设计，JSP 这种使用后端模板的技术也逐渐被淘汰了。

前面提到的 Tomcat 不仅支持了 Servlet，也支持了 JSP 技术。

下面使用 JSP 重写上面的Servlet，其结构目录会如下：

webapps   
  - MyFirstServlet     
    - WEB-INF （已无用）              
    - web.xml
    - XXX.jsp

我们可以看到，现在工程目录下的 WEB-INF 没有实质上的作用，只是为了拷贝到 Tomcat 的部署目录下。

大部分 Java Web 开发框架都是构建在 Servlet 和 JSP 两种技术之上的。

二、框架体系

随着 Java Web 技术的发展，人们对于纯 JSP 技术感觉越来越不满，于是产生了新的开发框架。最知名的当属所谓的 SSH，即 Struts，Spring 和 Hibernate 三大框架。

最近在移动互联网的浪潮中，大量新的 Web 技术诞生，例如基于 Python 的 Web 开发，Node 开发，以及 Golang 开发等。在敏捷开发领域，Struts 这样的更多面向 JSP 和 View 的框架逐渐式微。与之相反，Spring 朝着更加现代敏捷的方向发展，衍生出了 SpringMVC 和 SpringBoot 这样广受欢迎的框架，以及有广泛适用性的java构建工具maven，慢慢地变成了现代 Java Web 开发的主流。

1.SpringMVC框架

整个 Spring 框架最基础的部分是它的 IoC Container。SpringMVC 本身就是构建在 Spring IoC 之上的。

SpringMVC 是构建在 Servlet 基础之上的，它对外提供了一个名为 DispatchServlet 的类，这个类相当于是 SpringMVC 和 Servlet API 的一个交界点。
顾名思义，它也是 SpringMVC 当中对于请求处理的一个分发器。（它将 Servlet 传递过来的请求根据 URL 分发给对应的 Controller）

在前面的内容中我们可以看到，通过在 web.xml 文件里配置 url-pattern ，也可以起到分发请求的作用。
但是，如果有大量的 URL 都需要在 web.xml 进行配置时，整个 web.xml 就变成了一个灾难。
因此很多 Web 框架都选择避免 web.xml，在此之上构建自己的请求分发机制。

（1）信息预设——修改web.xml

需要修改 web.xml，进行基本信息预设：

<servlet>
        <servlet-name>MyFirstServletName</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

<servlet-mapping>
        <servlet-name>MyFirstServletName</servlet-name>
        <url-pattern>/*</url-pattern>
</servlet-mapping>

(2)构建控制器——配置controller

然后还得配置一个control类，用于接收请求，返回信息。

@Controller
public class MyFirstSpringController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public @ResponseBody String Hello() {
        return "Hello, SpringMVC.";
    }
}

（3）建立联系——创建-servlet.xml

最后，将Servlet与 DispatchServlet 和controller挂钩就完事了，创建一个 MyFirstServletName-servlet.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"
    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">

        <bean class="com.skyline.MyFirstSpringController"/>

</beans>

上面的配置中，我们将编写的 MyFirstSpringController 加入了 beans 列表，SpringMVC 就能找到我们的 Controller 并且进行初始化了，然后就可以在tomcat中部署实现了。

（4）Annotation

在前面的代码中，我们使用了诸如 @Controller 等 Annotation。要理解前面的代码，首先要对 Java 的 Annotation 语法有一定了解。考虑到并不是所有读者对于 Annotation 语法都很熟悉，这里简单做一下介绍。

Annotation，可以翻译成注解，可以看成对源代码的一种标注。注解本身不会对源代码产生任何影响，不过我们可以通过在编译器或者运行期检查代码中的注解，通过注解给代码引入更多的功能。

Java 语言本身就自带了一些注解，例如最常见的 @Override，用来标记方法是一个重载方法。以及 @Deprecated 用于标记代码为废弃。

为了编写自定义注解，需要使用 Java 提供的若干用于生成注解的注解，即所谓的元注解（Meta Annotations）。

简单理解就是，这些注解存在的作用，就是为了让我们可以编写自己的注解。

（5）POJO

Java 语言中引入了很多乍一看奇奇怪怪的概念，POJO 应该算是其中的一个。POJO 全称是 Plain Old Java Object，即普通的 Java 对象。单看全称的话，POJO 实在是没什么意义，我们随便写一个 Java 对象都可以被称为 POJO，而事实也正是如此，大部分 Java 对象都可以被称为 POJO。那么 POJO 这个概念实际上存在有什么意义呢？

实际上它是针对于EJB等这些依赖于某些框架，继承父类或实现接口导致的层层叠叠的复杂关系，这就叫依赖关系，专业点说就是耦合度很高。

POJO就是一个低耦合度的东西，尽量不依赖这个类以外的代码或Jar包，这样子它就会很独立，自由度很高，可以随意调整。上面的Annotation，其实就将这种依赖关系降低耦合度，变得更加灵活。

（6）JavaBean

JavaBean 实际上是对于用 Java 编写数据 Model 时的一种编程惯例，具体的要求是：

有无参的构造器
所有的成员都是 private，对外暴露 getter 和 setter方法
实现 Serializable接口

JavaBean 这个概念后来逐渐泛化，不再局限于 Model 类。Spring 把很多东西包括自己的一些组件也都称为 Bean，这个称呼可以看成是对 JavaBean 的进一步泛化。

2.Maven工具

Maven 是一个非常强大的 Java 构建工具，包含了依赖管理，版本维护，自动化构建等诸多功能，这里我们将主要使用它的依赖管理功能。

在工程名字上右键点击，选择“Add Framework Support”。在打开的对话框中，勾选 Maven，然后点击确定。工程中将会出现一个 pom.xml 文件，它的全称是 “project object model”，是 Maven 当中用来描述项目信息的一个文件：

<?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>MyJavaWebProject</groupId>
    <artifactId>MyJavaWebProject</artifactId>
    <version>1.0-SNAPSHOT</version>

</project>

而后，如果想要引入我们需要的依赖，在 pom.xml 当中加入以下内容：

<?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>

    <properties>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.source>1.8</maven.compiler.source>
    </properties>

    <groupId>MyJavaWebProject</groupId>
    <artifactId>MyJavaWebProject</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <!-这里添加所需要的依赖jar包->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.8.RELEASE</version>
        </dependency>

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

    </dependencies>
</project>

可以看到，我们对于依赖的描述，本质上也是对于一个项目的描述，和描述我们自己类似。通过这些信息，Maven 可以在中心仓库中找到正确的依赖项目并引入到我们的工程当中。

编译器会提示我们 POM 文件改变，选择“Import Changes”，会看到有关的依赖被加入到了 “External Library” 中：

个人通讯录JAVA程序代码 javaweb个人通讯录_spring

如果导入过程非常慢，那么可能是网络条件不良，我们可以修改中心仓库的地址，使用国内的 Maven 镜像。

这部分网络上教程很多，我就不再详细说了，阿里云的镜像下载地址还是比较快的。

在导入依赖之后，我们可以正常编译项目，后面的内容中，我们将通过 Maven 来添加需要的依赖，而不再需要手动下载 jar 包。

当然，如果你的项目需要布置在不联网的机器上，那么手动导入jar必不可少，其中想要导入maven库，需要在工程上右键选择导入，在maven项目中选定artifact那个栏目，然后将依赖包，以及相关的依赖信息、版本号、路径填入。

3.SpringBoot

SpringBoot 是构建在 SpringMVC 基础上的新一代 Web 开发框架。相比 SpringMVC，SpringBoot 的配置更简单，上手更容易，因此受到了开发者们的欢迎。下面我们将在前面内容的基础上，学习使用 SpringBoot。

(1)环境预设

在 pom.xml中加入对于 SpringBoot 的依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.3.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- ... -->
</dependencies>

（2）搭建项目

创建一个新的 SpringBoot 应用：

@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(applicationClass, args);
    }

    private static Class<MySpringBootApplication> applicationClass = MySpringBootApplication.class;
}

SpringBoot 内置了一个 Tomcat 服务器，也就是内嵌了一个 Servlet Container，因此直接运行工程就可以看到效果，不需要再进行额外的部署，也无需进行 Servlet 的有关配置。同时 SpringBoot 还会帮我们做许多配置工作。

通过 @SpringBootApplication 这个 Annotation，它会帮我们打开 @EnableWebMvc，以及 @ComponentScan 功能，这意味着 SpringBoot 会和 SpringMvc 找到同一个 package 下的 @Controller，@Configuration 等类，进行自动配置。

（3）应用tomcat服务

只需要继承 SpringBootServletInitializer，整个应用就具备了部署到 Servlet Container 的能力：

@SpringBootApplication
public class MySpringBootApplication extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication.run(applicationClass, args);
    }

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(applicationClass);
    }

    private static Class<MySpringBootApplication> applicationClass = MySpringBootApplication.class;
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。