JAVA开发技术之简单WEB服务开发

来源：互联网发布：阿里云rds数据库编辑：程序博客网时间：2024/05/16 06:21

一、必备基础技能

必备技能：JAVA基础知识、html、JavaScript、tomcat、数据库（mysql）、eclipse

1、JAVA基础知识

JAVA基础知识涵盖比较广，主要是能比较全面的了解JAVA开发语言语法和编码规范，理解JAVA程序的运行原理，理解JVM的作用和其内部运行机制。

自行补脑方式：找一本关于java基础开发技能的图书看看，或者网上下载教学视频观看。

2、html

理解html语言，DOM模型，推荐到http://w3school.com.cn/ 网站上学习。

3、JavaScript

掌握JavaScript脚本语言的编写规范，使用JavaScript开发前端处理逻辑，推荐到http://w3school.com.cn/ 网站上学习。

4、tomcat

主要掌握如何安装tomcat、配置tomcat、tomcat和ecplipse集成。

5、数据库（mysql）

Mysql数据库的安装和配置，常用查询语句的编写，mysql数据库的维护。

6、eclipse

eclipse是一个开放源代码的、基于java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。Eclipse附带了一个标准的插件集，包括java开发工具（JavaDevelopment Kit, JDK）。

熟练使用eclipse集成开发环境对于快速开发JVAVA项目有很大帮助，需要对eclipse的基本操作熟练掌握。

二、关键技术介绍

关键技术：JavaBean、servlet、spring、MyBatis

1、JavaBean

JavaBean是特殊的Java类，使用J ava语言书写，并且遵守JavaBean API规范。

JavaBean与其它Java类相比而言独一无二的特征：

·提供一个默认的无参构造函数。

·需要被序列化并且实现了Serializable接口。

·有一系列可读写属性。

·有一系列的"getter"或"setter"方法。

JavaBean属性

一个JavaBean对象的属性可以是可读写，或只读，或只写。JavaBean对象的属性通过JavaBean实现类中提供的两个方法来访问：

方法

描述

getPropertyName()

举例来说，如果属性的名称为myName，那么这个方法的名字就要写成getMyName()来读取这个属性。这个方法也称为访问器。

setPropertyName()

举例来说，如果属性的名称为myName，那么这个方法的名字就要写成setMyName()来写入这个属性。这个方法也称为写入器。

一个只读的属性只提供getPropertyName()方法，一个只写的属性只提供setPropertyName()方法。

JavaBean 程序示例

这是StudentBean.java文件：

package com.runoob;

public class StudentsBean implements java.io.Serializable

{

private String firstName = null;

private String lastName = null;

private int age = 0;

public StudentsBean() {

}

public String getFirstName(){

return firstName;

}

public String getLastName(){

return lastName;

}

public int getAge(){

return age;

}

public void setFirstName(String firstName){

this.firstName= firstName;

}

public void setLastName(String lastName){

this.lastName= lastName;

}

public void setAge(int age){

this.age= age;

}

访问JavaBean

<jsp:useBean> 标签可以在JSP中声明一个JavaBean，然后使用。声明后，JavaBean对象就成了脚本变量，可以通过脚本元素或其他自定义标签来访问。<jsp:useBean>标签的语法格式如下：

<jsp:useBean id="bean的名字"scope="bean的作用域"class="bean类型"/>

这行代码的含义是：“创建一个由class属性指定的类的实例，然后把它绑定到其名字由id属性给出的变量上”。

注意：只有当不存在同样id和scope的Bean时才创建新的对象实例

我们既可以通过jsp:setProperty动作的value属性直接提供一个值，也可以在JSP中利用id属性所命名的对象变量，通过调用该对象的方法显式地修改其属性(比如:<% guessBiz.setName("name"); %>)。

属性用法:

属性

描述

命名引用该Bean的变量。如果能够找到id和scope相同的Bean实例，jsp:useBean动作将使用已有的Bean实例而不是创建新的实例。

class

指定Bean的完整包名。

scope

指定Bean在哪种上下文内可用，可以取下面的四个值之一：page，request，session和application。
默认值是page，表示该Bean只在当前页面内可用（保存在当前页面的PageContext内）。
request表示该Bean在当前的客户请求内有效（保存在ServletRequest对象内）。
session表示该Bean对当前HttpSession内的所有页面都有效。
最后，如果取值application，则表示该Bean对所有具有相同ServletContext的页面都有效。
scope之所以很重要，是因为jsp:useBean只有在不存在具有相同id和scope的对象时才会实例化新的对象；如果已有id和scope都相同的对象则直接使用已有的对象，此时jsp:useBean开始标记和结束标记之间的任何内容都将被忽略。

type

指定引用该对象的变量的类型，它必须是Bean类的名字、超类名字、该类所实现的接口名字之一;请记住变量的名字是由id属性指定的;如果提供了type属性，允许省略class属性。

beanName

指定Bean的名字。如果提供了beanName属性，允许省略class属性。

<jsp:useBean> 标签的一个简单的用法：

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>

<html>

<head>

<title>get 和 set 属性实例</title>

</head>

<body>

<jsp:useBean id="students"  class="com.runoob.StudentsBean">

   <jsp:setProperty name="students" property="firstName" value="小强"/>

   <jsp:setProperty name="students" property="lastName"  value="王"/>

   <jsp:setProperty name="students" property="age" value="10"/>

</jsp:useBean>

<p>学生名字:

   <jsp:getProperty name="students" property="firstName"/>

</p>

<p>学生姓氏:

   <jsp:getProperty name="students" property="lastName"/>

</p>

<p>学生年龄:

   <jsp:getProperty name="students" property="age"/>

</p>

</body>

</html>

访问以上 JSP，运行结果如下：

学生名字: 小强

学生姓氏: 王

学生年龄: 10

2、servlet

Servlet 是什么？

Java Servlet 是运行在 Web服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。

使用 Servlet，可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。

Java Servlet 通常情况下与使用 CGI（Common Gateway Interface，公共网关接口）实现的程序可以达到同样的效果。

Servlet 架构

下图显示了 Servlet 在 Web 应用程序中的位置。

Servlet 任务

Servlet 执行以下主要任务：

·读取客户端（浏览器）发送的显式的数据。这包括网页上的 HTML表单，或者也可以是来自 applet 或自定义的 HTTP 客户端程序的表单。

·读取客户端（浏览器）发送的隐式的 HTTP请求数据。这包括 cookies、媒体类型和浏览器能理解的压缩格式等等。

·处理数据并生成结果。调用 Web服务程序，这个过程可能需要访问数据库，或者直接计算得出对应的响应。

·发送显式的数据（即文档）到客户端（浏览器）。该文档的格式可以是多种多样的，包括文本文件（HTML或 XML）、二进制文件（GIF图像）、Excel 等。

·发送隐式的 HTTP响应到客户端（浏览器）。这包括告诉浏览器或其他客户端被返回的文档类型（例如HTML），设置 cookies 和缓存参数，以及其他类似的任务。

3、spring

Spring简介

Spring框架由Rod Johnson开发，2004年发布了Spring框架的第一版。Spring是一个从实际开发中抽取出来的框架，因此它完成了大量开发中的通用步骤，留给开发者的仅仅是与特定应用相关的部分，从而大大提高了企业应用的开发效率。

Spring总结起来优点如下：

· 低侵入式设计，代码的污染极低。

· 独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once，Run Anywhere的承诺。

· Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦。

· Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用。

· Spring的ORM(Object RelationalMapping)和DAO (Data Access Objects) 提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。

· Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部。

Spring框架的组成结构图如下所示：

Spring的核心机制

管理Bean

程序主要是通过Spring容器来访问容器中的Bean，ApplicationContext是Spring容器最常用的接口，该接口有如下两个实现类：

· ClassPathXmlApplicationContext:从类加载路径下搜索配置文件，并根据配置文件来创建Spring容器。

· FileSystemXmlApplicationContext:从文件系统的相对路径或绝对路径下去搜索配置文件，并根据配置文件来创建Spring容器。

public class BeanTest{

public static void main(String args[])throwsException{

ApplicationContext ctx=new ClassPathXmlApplicationContext("beans.xml");

Person p = ctx.getBean("person",Person.class);

p.say();

}

Eclipse使用Spring

在Eclipse等IDE工具中，用户可以自建UserLibrary，然后把Spring的Jar包都放入其中，当然也可以将Jar包直接放在项目的/WEB-INF/lib目录下，但是如果使用UserLibrary，在项目发布时，需要将用户库所引用的Jar文件随应用一起发布，就是将User Library所使用的Jar复制到/WEB-INF/lib目录下，这是因为对于一个Web应用，Eclipse部署Web应用时不会将用户库的Jar文件复制到/WEB-INF/lib下，需要手动复制。

依赖注入

Spring框架的核心功能有两个：

·Spring容器作为超级大工厂，负责创建、管理所有的Java对象，这些Java对象被称为Bean。

·Spring容器管理容器中Bean之间的依赖关系，Spring使用一种被称为"依赖注入"的方式来管理Bean之间的依赖关系。

使用依赖注入，不仅可以为Bean注入普通的属性值，还可以注入其他Bean的引用。依赖注入是一种优秀的解耦方式，其可以让Bean以配置文件组织在一起，而不是以硬编码的方式耦合在一起。

理解依赖注入

Rod Johnson是第一个高度重视以配置文件来管理Java实例的协作关系的人，他给这种方式起了一个名字：控制反转（Inverse ofControl，IoC）。后来Martine Fowler为这种方式起了另一个名称：依赖注入（Dependency Injection），因此不管是依赖注入，还是控制反转，其含义完全相同。当某个Java对象（调用者）需要调用另一个Java对象（被依赖对象）的方法时，在传统模式下通常有两种做法：

1. 原始做法:调用者主动创建被依赖对象，然后再调用被依赖对象的方法。

2. 简单工厂模式:调用者先找到被依赖对象的工厂，然后主动通过工厂去获取被依赖对象，最后再调用被依赖对象的方法。

注意上面的主动二字，这必然会导致调用者与被依赖对象实现类的硬编码耦合，非常不利于项目升级的维护。使用Spring框架之后，调用者无需主动获取被依赖对象，调用者只要被动接受Spring容器为调用者的成员变量赋值即可，由此可见，使用Spring后，调用者获取被依赖对象的方式由原来的主动获取，变成了被动接受——所以Rod Johnson称之为控制反转。

另外从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量——相当于为调用者注入它依赖的实例，因此Martine Fowler称之为依赖注入。

设值注入

设值注入是指IoC容器通过成员变量的setter方法来注入被依赖对象。这种注入方式简单、直观，因而在Spring的依赖注入里大量使用。

构造注入

利用构造器来设置依赖关系的方式，被称为构造注入。通俗来说，就是驱动Spring在底层以反射方式执行带指定参数的构造器，当执行带参数的构造器时，就可利用构造器参数对成员变量执行初始化——这就是构造注入的本质。

两种注入方式的对比

设值注入有如下优点：

·与传统的JavaBean的写法更相似，程序开发人员更容易理解、接受。通过setter方法设定依赖关系显得更加直观、自然。

·对于复杂的依赖关系，如果采用构造注入，会导致构造器过于臃肿，难以阅读。Spring在创建Bean实例时，需要同时实例化其依赖的全部实例，因而导致性能下降。而使用设值注入，则能避免这些问题。

·尤其在某些成员变量可选的情况下，多参数的构造器更加笨重。

构造注入优势如下：

·构造注入可以在构造器中决定依赖关系的注入顺序，优先依赖的优先注入。

·对于依赖关系无需变化的Bean，构造注入更有用处。因为没有setter方法，所有的依赖关系全部在构造器内设定，无须担心后续的代码对依赖关系产生破坏。

·依赖关系只能在构造器中设定，则只有组件的创建者才能改变组件的依赖关系，对组件的调用者而言，组件内部的依赖关系完全透明，更符合高内聚的原则。

注意：
建议采用设值注入为主，构造注入为辅的注入策略。对于依赖关系无须变化的注入，尽量采用构造注入；而其他依赖关系的注入，则考虑采用设值注入。

Spring容器中的Bean

对于开发者来说，开发者使用Spring框架主要是做两件事：①开发Bean；②配置Bean。对于Spring框架来说，它要做的就是根据配置文件来创建Bean实例，并调用Bean实例的方法完成"依赖注入"——这就是所谓IoC的本质。

容器中Bean的作用域

当通过Spring容器创建一个Bean实例时，不仅可以完成Bean实例的实例化，还可以为Bean指定特定的作用域。Spring支持如下五种作用域：

1. singleton:单例模式，在整个Spring IoC容器中，singleton作用域的Bean将只生成一个实例。

2. prototype:每次通过容器的getBean()方法获取prototype作用域的Bean时，都将产生一个新的Bean实例。

3. request:对于一次HTTP请求，request作用域的Bean将只生成一个实例，这意味着，在同一次HTTP请求内，程序每次请求该Bean，得到的总是同一个实例。只有在Web应用中使用Spring时，该作用域才真正有效。

4. 对于一次HTTP会话，session作用域的Bean将只生成一个实例，这意味着，在同一次HTTP会话内，程序每次请求该Bean，得到的总是同一个实例。只有在Web应用中使用Spring时，该作用域才真正有效。

5. global session:每个全局的HTTP Session对应一个Bean实例。在典型的情况下，仅在使用portlet context的时候有效，同样只在Web应用中有效。

如果不指定Bean的作用域，Spring默认使用singleton作用域。prototype作用域的Bean的创建、销毁代价比较大。而singleton作用域的Bean实例一旦创建成果，就可以重复使用。因此，应该尽量避免将Bean设置成prototype作用域。

使用自动装配注入Bean

Spring能自动装配Bean与Bean之间的依赖关系，即无须使用ref显式指定依赖Bean，而是由Spring容器检查XML配置文件内容，根据某种规则，为调用者Bean注入被依赖的Bean。
Spring自动装配可通过<beans/>元素的default-autowire属性指定，该属性对配置文件中所有的Bean起作用；也可通过对<bean/>元素的autowire属性指定，该属性只对该Bean起作用。

Spring配置文件样例：

4、MyBatis

Mybatis来历

MyBatis的前身就是iBatis,iBatis本是由Clinton Begin开发，后来捐给Apache基金会，成立了iBatis开源项目。2010年5月该项目由Apahce基金会迁移到了Google Code，并且改名为MyBatis。

什么是MyBatis

MyBatis是一个数据持久层(ORM)框架。把实体类和SQL语句之间建立了映射关系，是一种半自动化的ORM实现。

MyBatis的优点：
1. 基于SQL语法，简单易学。
2. 能了解底层组装过程。
3. SQL语句封装在配置文件中，便于统一管理与维护，降低了程序的耦合度。
4. 程序调试方便。

mybatis架构图：

解释：

1、mybatis基本配置文件配置了mybatis运行环境信息，包含：数据连接池、数据库事务管理等，映射配置文件配置sql语句，要在基本配置文件中加载

2、通过mybatis环境配置文件构造会话工厂及SqlSessionFactory

3、通过SqlSessionFactory会话工厂创建会话即SqlSession,sql通过会话执行

4、mybatis低层定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器，一个是缓存执行器

5、MappedStatement是mybatis低层的封装对象，它封装了mybatis基本配置信息和映射信息，一个sql语句对应一个MappedStatement对象，它的id就是sql语句的id

6、MappedStatement对执行语句的输入参数进行定义包含：基本数据类型、HashMap、POJO等，Executor通过MappedStatement在执行sql前将输入的java对象映射至sql中

7、MappedStatement对执行语句的输出结果进行定义包含：基本数据类、HashMap、POJO等，Executor通过MappedStatement将sql语句执行后的结果映射为java对象

三、简单WEB服务开发流程

流程：创建JAVA-WEB工程－>创建mysql数据库－>开发servlet－>开发前端界面－>调试程序

1、创建JAVA-WEB工程

创建JAVA-WEB工程之前需要安装和配置好jdk1.8的JVM环境

第一步：创建工程

生成的java工程结构如下：

配置工程默认字符集为UTF-8：

第二步：引入框架依赖包

Servlet依赖包列表：

servlet-api.jar

spring依赖包列表：

spring-web-4.3.8.RELEASE.jar

spring-aop-4.3.8.RELEASE.jar

spring-beans-4.3.8.RELEASE.jar

spring-context-4.3.8.RELEASE.jar

spring-core-4.3.8.RELEASE.jar

spring-expression-4.3.8.RELEASE.jar

spring-jdbc-4.3.8.RELEASE.jar

spring-tx-4.3.8.RELEASE.jar

mybatis依赖包列表：

mybatis-3.2.2.jar

mybatis-spring-1.2.0.jar

mysql-connector-java-5.1.26.jar

其他依赖包列表：

aopalliance-1.0.jar

commons-io-1.3.2.jar

commons-logging-1.1.1.jar

commons-pool-1.6.jar

log4j-1.2.13.jar

slf4j-api-1.7.5.jar

slf4j-log4j12-1.7.2.jar

commons-lang-2.4.jar

commons-beanutils-1.8.3.jar

commons-collections-3.2.jar

commons-lang3-3.4.jar

json-lib-2.4-jdk15.jar

c3p0-0.9.1.1.jar

ezmorph-1.0.6.jar

将上面的依赖包拷贝到WebContent/WEB-INF/lib目录下面，然后添加到工程依赖中

第三步：框架集成配置

配置web.xml，在WebContent/WEB-INF/web.xml中添加如下配置

<?xmlversion="1.0"encoding="UTF-8"?>

<web-appversion="2.4"

xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation=" http://java.sun.com/xml/ns/j2ee

http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<welcome-file-list>

<welcome-file>index.html</welcome-file>

</welcome-file-list>

<context-param>

<param-name>webAppRootKey</param-name>

<param-value>webApp.SM1</param-value>

</context-param>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext.xml</param-value>

</context-param>

<listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

</dependency>

</dependency>

<context-param>

<param-name>log4jConfigLocation</param-name>

<param-value>classpath:log4j.properties</param-value>

</context-param>

<context-param>

<param-name>log4jRefreshInterval</param-name>

<param-value>60000</param-value>

</context-param>

<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>

</listener>

</web-app>

在source目录下面增加下面3个配置文件：

applicationContext.xml

log4j.properties

mybatis-config.xml

配置文件内容如下：其中红色字体部分需要根据实际情况修改

applicationContext.xml:

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:jdbc="http://www.springframework.org/schema/jdbc"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="

http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/jdbchttp://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd

http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.0.xsd"

default-autowire="byName">

<context:annotation-config/>

<context:component-scanbase-package="com.hw"/>

<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource"destroy-method="close">

<propertyname="driverClass"value="com.mysql.jdbc.Driver"/>

<propertyname="jdbcUrl"value="jdbc:mysql://10.41.30.62:3306/tcep"/>

<propertyname="user"value="root"/>

<propertyname="password"value="*Vmall123*"/>

<propertyname="minPoolSize"value="1"/>

<propertyname="maxPoolSize"value="10"/>

</bean>

<beanname="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<propertyname="dataSource"ref="dataSource"></property>

</bean>

<beanid="sqlSessionFactory"class="org.mybatis.spring.SqlSessionFactoryBean">

<propertyname="dataSource"ref="dataSource"/>

<propertyname="configLocation"value="classpath:mybatis-config.xml">

</property>

</bean>

<beanid="MockMapper"class="org.mybatis.spring.mapper.MapperFactoryBean">

<propertyname="sqlSessionFactory"ref="sqlSessionFactory"/>

<propertyname="mapperInterface"value="com.hw.mall.test.mapper.MockMapper"/>

</bean>

</beans>

log4j.properties：

log4j.rootLogger=debug, stdout, logfile

log4j.logger.com.fiscal = WARN

log4j.logger.com.system = WARN

log4j.logger.org.apache = WARN

log4j.logger.com.ibatis = WARN

log4j.logger.com.mchange = WARN

log4j.logger.org.springframework = WARN

log4j.logger.org.apache.ibatis.logging.slf4j.Slf4jImpl=WARN

log4j.logger.com.ibatis.common.jdbc.SimpleDataSource = debug

log4j.logger.com.ibatis.common.jdbc.ScriptRunner = debug

log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate =debug

log4j.logger.java.sql.Statement = debug

log4j.logger.java.sql.PreparedStatement = debug

log4j.logger.java.sql.ResultSet = WARN

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=%d[%p](%F:%L%M)- %m%n

log4j.appender.logfile=org.apache.log4j.RollingFileAppender

log4j.appender.logfile.File=${webApp.SM1}/logs/run.log

log4j.appender.logfile.MaxFileSize=51200KB

log4j.appender.logfile.MaxBackupIndex=100

log4j.appender.logfile.layout=org.apache.log4j.PatternLayout

log4j.appender.logfile.layout.ConversionPattern=%d[%p](%F\:%L%M)- %m%n

mybatis-config.xml:

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEconfigurationPUBLIC"-//mybatis.org//DTD Config 3.0//EN""http://mybatis.org/dtd/mybatis-3-config.dtd">

<mapperresource="com/hw/mall/test/mapper/Mock.xml"/>

</mappers>

</configuration>

2、创建mysql数据库

创建数据库前必须已经安装好mysql数据库系统

使用Navicat Premium在图像界面创建mysql数据库实例

新增完成数据库实例后打开实例如下所示：

创建表结构：根据项目需要创建数据库表结构

创建表结构的sql样例：

CREATETABLE `mock` (

`id` int(10) NOT NULL AUTO_INCREMENT,

`interfaceName` varchar(100) DEFAULT NULLCOMMENT '接口名称',

`methodName` varchar(100) DEFAULT NULLCOMMENT '方法名称',

`paramTypes` varchar(100) DEFAULT NULLCOMMENT '参数类型',

`paramJson` varchar(10000) DEFAULT NULLCOMMENT '参数JSON串',

`returnType` varchar(100) DEFAULT NULLCOMMENT '返回类型',

`returnJson` varchar(10000) DEFAULT NULLCOMMENT '响应JSON串',

`keyword` varchar(100) DEFAULT NULL COMMENT '关键字',

`status` int(1) DEFAULT NULL COMMENT '接口mock状态:0=不mock, 1=mock',

PRIMARY KEY (`id`)

)ENGINE=InnoDB AUTO_INCREMENT=118 DEFAULT CHARSET=utf8;

3、开发servlet

第一步：新建包结构

按照以上方法添加3个包，servlet、service、mapper、util

添加完成后如下：

第二步：新建utils类

Utils类中添加常用方法，完整类的内容如下：

package com.hw.mall.test.util;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

public class Utils {

/**

* 该方法主要是实现向客户端发送信息

* Stringcontent 发送信息内容

public static voidsendMsg(HttpServletResponseresponse, Stringcontent)

{

PrintWriter out = null;

try {

response.setCharacterEncoding("UTF-8");

out = response.getWriter();

} catch (IOExceptione)

{

e.printStackTrace();

}

out.write(content);

out.flush();

out.close();

}

/**

* 读取POST请求内容数据.

* HttpServletRequest request

@SuppressWarnings("finally")

public static StringgetMsg(HttpServletRequest request) {

BufferedReader br;

String line = null;

StringBuilder sb = null;

String result = "";

try {

InputStreamReader reader =new InputStreamReader(request.getInputStream(),"UTF-8");

br = new BufferedReader(reader);

sb = new StringBuilder();

while((line =br.readLine())!=null){

sb.append(line);

}

result = sb.toString();

}

catch (Exceptione)

{

e.printStackTrace();

}

finally {

returnresult;

}

第三步：新建servlet类

在servlet包中新建servlet类，每个动态请求需要创建一个servlet类

添加doGet、doPost方法：

在doGet方法内添加业务代码，完整类内容如下：

package com.hw.mall.test.servlet;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import javax.servlet.ServletConfig;

import javax.servlet.ServletException;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.context.support.SpringBeanAutowiringSupport;

import com.hw.mall.test.service.MockService;

import com.hw.mall.test.util.Utils;

@WebServlet("/addMock")

public class addMock extends HttpServlet {

private static final long serialVersionUID = 1L;

private Loggerlogger = Logger.getLogger(addMock.class);

@Autowired

private MockServicemockService;

/**

* init 配置servlet中使用@Autowired能被spring管控

public void init(ServletConfig config)throws ServletException {

super.init(config);

SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(this,config.getServletContext());

}

/**

* get

protected voiddoGet(HttpServletRequest request, HttpServletResponseresponse)throws ServletException, IOException {

if(null ==request) {

return;

}

try

{

Map<String, Object> map =new HashMap<String,Object>();

map.put("interfaceName",request.getParameter("interfaceName"));

map.put("methodName",request.getParameter("methodName"));

map.put("paramTypes",request.getParameter("paramTypes"));

map.put("paramJson",request.getParameter("paramJson"));

map.put("returnType",request.getParameter("returnType"));

map.put("returnJson",request.getParameter("returnJson"));

map.put("status",request.getParameter("status"));

mockService.addMock(map);

Utils.sendMsg(response,"{\"success\":true,\"message\":\"执行成功\"}");

}

catch(Exceptione)

{

logger.error(e);

Utils.sendMsg(response,"{\"success\":false,\"errorMsg\":\"" +e.toString() +"\"}");

}

/**

* post

protected voiddoPost(HttpServletRequest request, HttpServletResponseresponse)throws ServletException, IOException {

doGet(request, response);

}

按照上面的方法添加其他动态请求servlert类

第四步：新建service类

新建service接口类

在service接口类中添加servlet调用的方法，完整类内容如下：

package com.hw.mall.test.service;

import java.util.Map;

public interface MockService {

void addMock(Map<String,Object>map);

}

新建serviceImpl类

此为service接口的实现类，必须实现service接口中的所有方法，完整类内容如下：

package com.hw.mall.test.service;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import com.hw.mall.test.mapper.MockMapper;

@Service("MockService")

public class MockServiceImpl implements MockService {

@Autowired

private MockMappermockMapper;

@Override

public void addMock(Map<String,Object> map){

mockMapper.addMock(map);

}

第五步：新建mapper类

此类是mybatis持久化的映射接口类，每个方法映射到第五步中的xml映射文件中的一条SQL，完整的类内容如下：

package com.hw.mall.test.mapper;

import java.util.Map;

public interface MockMapper {

void addMock(Map<String,Object>map);

}

此类需要在applicationContext.xml文件中配置BEAN注入

<beanid="MockMapper"class="org.mybatis.spring.mapper.MapperFactoryBean">

<propertyname="sqlSessionFactory"ref="sqlSessionFactory"/>

<propertyname="mapperInterface"value="com.hw.mall.test.mapper.MockMapper"/>

</bean>

第六步：新建XML映射文件

此XML文件是映射SQL文件，一条SQL映射MockMapper中的一个方法，完整文件内容如下：

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEmapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mappernamespace="com.hw.mall.test.mapper.MockMapper">

<selectid="addMock"parameterType="Map">

insert intomock(interfaceName,

methodName,

paramTypes,

paramJson,

returnType,

returnJson,

keyword,

status)

VALUES(#{interfaceName},

#{methodName},

#{paramTypes},

#{paramJson},

#{returnType},

#{returnJson},

'',

#{status})

</select>

</mapper>

此文件路径需要在mybatis-config.xml文件配置：

<mapperresource="com/hw/mall/test/mapper/Mock.xml"/>

</mappers>

以上步骤完整后工程目录结构如下：

4、开发前端界面

第一步：新建首页index.html

在WebContent目录下面新建index.html页面

引入jquery-easyui-1.5.2前端开发框架

下载jquery-easyui-1.5.2框架包，将包解压后放到WebContent目录下面

使用easyui提供的Basic Layout和Basic CRUD Application组件设计首页index.html

完整html内容：

<!DOCTYPEhtml>

<html>

<head>

<metacharset="UTF-8">

<title>project-j1</title>

<linkrel="stylesheet"type="text/css"href="jquery-easyui-1.5.2/themes/default/easyui.css">

<linkrel="stylesheet"type="text/css"href="jquery-easyui-1.5.2/themes/icon.css">

<linkrel="stylesheet"type="text/css"href="jquery-easyui-1.5.2/demo/demo.css">

<scripttype="text/javascript"src="jquery-easyui-1.5.2/jquery.min.js"></script>

<scripttype="text/javascript"src="jquery-easyui-1.5.2/jquery.easyui.min.js"></script>

</head>

<body>

<divclass="easyui-layout"style="width:100%;height:600px;">

<divdata-options="region:'north'"style="height:50px;background:#557fc3;color:yellow">

<h2style="text-align:center;vertical-align:middle;height:30px;margin-bottom:5px;margin-top:13px;">性能测试执行平台</h2>

</div>

<divdata-options="region:'west',split:true"title="导航栏"style="width:120px;">

<divclass="easyui-accordion"data-options="fit:true,border:false">

<divtitle="接口MOCK"style="padding:10px;">

<ahref="mock.html"style="display:block;width:80px;height:18px;border:1.5px solid #000000;background:#336699;font-size:14px;margin-top:10px;padding:2px 6px;color:#ffffff;text-decoration:none;"

target="Iframe"onClick='setNavigationBar("接口MOCK", "MOCK管理")'>MOCK管理</a>

</div>

<divdata-options="region:'center',title:'workspace',iconCls:'icon-ok'">

<iframeid="frame"name="Iframe"frameborder="0"scrolling="no"src="mock.html"

style="width:100%;height:99%;overflow:hidden;border:0px solid red;">

</iframe>

</div>

$(document).ready(function(e)

{

setNavigationBar("接口MOCK","MOCK管理");

});

/**

* 更改导航栏名称

* @parambar1: 上一层的名称

* @parambar2: 当前层的名称

function setNavigationBar(bar1,bar2)

{

currentFuncName= [];

currentFuncName.push(bar1);

var trHtml = bar1;

if (bar2)

{

currentFuncName.push(bar2);

trHtml+= " <b>></b> "+ bar2;

}

getByClass("panel-with-icon")[0].innerHTML=trHtml;;

}

*通过classname获取元素

function getByClass(sClass){

var aResult=[];

varaEle=document.getElementsByTagName('*');

for(vari=0;i<aEle.length;i++){

/*将每个className拆分*/

vararr=aEle[i].className.split(/\s+/);

for(varj=0;j<arr.length;j++){

/*判断拆分后的数组中有没有满足的class*/

if(arr[j]==sClass){

aResult.push(aEle[i]);

}

return aResult;

};

</script>

</body>

</html>

第二步：新建业务子页mock.html

在WebContent目录下面新建mock.html页面，此页面需要嵌入到首页index.html中

完整html内容：

<!DOCTYPEhtml>

<html>

<head>

<metacharset="UTF-8">

<linkrel="stylesheet"type="text/css"href="jquery-easyui-1.5.2/themes/default/easyui.css">

<linkrel="stylesheet"type="text/css"href="jquery-easyui-1.5.2/themes/icon.css">

<linkrel="stylesheet"type="text/css"href="jquery-easyui-1.5.2/demo/demo.css">

<scripttype="text/javascript"src="jquery-easyui-1.5.2/jquery.min.js"></script>

<scripttype="text/javascript"src="jquery-easyui-1.5.2/jquery.easyui.min.js"></script>

</head>

<body>

<tableid="dg"title="MOCK管理"class="easyui-datagrid"style="width:100%;height:100%"

url="getMock"toolbar="#toolbar"pagination="true"

rownumbers="true"fitColumns="true"singleSelect="true">

<thead>

<tr>

<thfield="interfaceName"width="50">接口服务</th>

<thfield="methodName"width="50">接口方法</th>

<thfield="paramTypes"width="50">参数类型</th>

<thfield="paramJson"width="100">参数JSON</th>

<thfield="returnType"width="50">返回类型</th>

<thfield="returnJson"width="100">返回JSON</th>

<thfield="status"width="45">mock开关(0关,1开)</th>

</tr>

</thead>

</table>

<divid="toolbar">

<ahref="javascript:void(0)"class="easyui-linkbutton"iconCls="icon-add"plain="true"onclick="newMock()">添加mock接口</a>

<ahref="javascript:void(0)"class="easyui-linkbutton"iconCls="icon-edit"plain="true"onclick="editMock()">修改mock接口</a>

<ahref="javascript:void(0)"class="easyui-linkbutton"iconCls="icon-remove"plain="true"onclick="destroyMock()">删除mock接口</a>

</div>

<divid="dlg"class="easyui-dialog"style="width:1000px"

closed="true"buttons="#dlg-buttons">

<formid="fm"method="post"novalidatestyle="margin:0;padding:20px 50px">

<divstyle="margin-bottom:20px;font-size:14px;border-bottom:1px solid #ccc">Mock Information</div>