Selenium+java - 手把手一起搭建一个最简单自动化测试框架

写在前面

我们刚开始做自动化测试，可能写的代码都是基于原生写的代码，看起来特别不美观，而且感觉特别生硬。

来看下面一段代码,如下图所示：

从上面图片代码来看，具体特征如下：

  • driver对象在测试类中显示
  • 定位元素的value值在测试类中显示
  • 定位元素的方式（By对象）在测试类中显示
  • 代码一报错，还要去测试类里面找是哪段代码报错，要是代码行数几百行时呢，就不好定位问题了
  • 这样的测试脚本组装批量执行，批量报错后，怒号排查，定位问题，很吃力

看看自己有几条命中呢，其他现象就不一一列举了。

1、为什么要写自动化测试框架

从个人方面来说：

  • 逼格高，让别人感觉你好厉害，技术强
  • 面试是加分项，会写框架，可以作为谈资硬性指标
  • 一个组内，要是妹纸多，你可以秀技能，吸引妹纸也说不定呢
  • 对自己而言，更是一种挑战和提升

从实际方面来说：

  • 提高脚本编写效率，脚本的可读性，可降低代码维护成本
  • 方便定位问题，失败定位问题会比较方便
  • 可以提升测试效率，编写脚本成本，拿来就用，直接点方法就行
  • 减少了手工测试成本，节省人力成本

2、框架设计思路与实现

框架的几大要素：driver，元素管理，脚本，数据，元素对象，LOG，报告，运行机制，失败用例

框架的分层思想：脚本，数据，元素对象分离，使用Page Object和Page Factory思想，这里我将框架分为四层：基础层、元素对象层、操作层、业务层。

这里我们以163邮箱登录为例，进行讲解。

具体代码目录结构如下：

下面我们将进入大家都比较关注的话题了，这里我只分享思路哈，跟上步伐，别掉队哦

2.1、log4j日志配置

关于log4j，这部分不是讲解重点，因为只需配置一次可以一直使用，下面的配置是拿来就能用的，有兴趣的同学可以自行百度去学习，本文只是为了使用log4j的日志效果。

添加配置文件log4j.properties，具体如下：

###根logger设置###
log4j.rootLogger = INFO,console,file

### 输出信息到控制台###
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.Threshold = info
log4j.appender.console.layout.ConversionPattern = [%p] %d{yyyy-MM-dd HH:mm:ss} method: %l----%m%n

###输出INFO 级别以上的日志文件设置###
log4j.appender.file = org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File = D:/log/web.log
log4j.appender.file.Append = true
log4j.appender.file.Threshold = info
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = %d{yyyy-MM-dd HH:mm:ss} method: %l - [ %p ]----%m%nH

新建测试类，名为TestLog,具体示例代码如下：

package com.frame.demo.test;

import org.apache.log4j.Logger;
import org.testng.annotations.Test;

public class TestLog {
    /**
     * log4j日志
     */
    private static Logger logger = Logger.getLogger(TestLog.class);
    @Test
    public void testLog() {
        logger.info("this is info log!!");
        logger.error("this is error log!!");
    }
}

运行效果如下图：

2.2、基础层的实现

用于封装浏览器对象，这里只写了firefox 和 chrome两种浏览器，有兴趣的同学可自行扩展。

具体代码示例如下：

package com.frame.demo.base;

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;

/**
 * @author rongrong
 */
public class GetDriverUtil {

    /**
     * @param browersName
     * @return
     */
    public static WebDriver getDriver(String browersName) {
        if (browersName.equalsIgnoreCase("firefox")) {
            return new FirefoxDriver();
        } else {
            System.setProperty("webdriver.chrome.driver", "chromedriver.exe");
            return new ChromeDriver();
        }
    }

}

2.3、元素对象管理与实现

为什么要做元素对象管理，因为在一个页面中有几十个元素对象，而一个网站有多个页面，一旦页面元素发生变化，维护起来不是很方便，因此，我们可以把需要录入的定位元素集中地放在一个地方去管理维护，而不是分散在测试用例脚本（代码）中。

这样的好处就是，可以提升些许编写脚本速度，降低后期维护成本，这时如果UI变了，我们只需要修改对应的页面中的元素定位即可。

具体数据源格式如下：

2.31、解析Excel文件

我们可以使用xml、yaml、excel、csv、mysql等等去存储管理元素对象数据，鉴于我们测试同学习惯用Excel去编写维护用例，本案例就以Excel为数据源，来进行元素的管理和维护，其他文件去维护管理的，有兴趣的同学可以去尝试。

首先来解析Excel文件，在pom.xml中添加依赖，如下：

        <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.16</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.16</version>
        </dependency>

解析excel文件，具体示例代码如下：

package com.frame.demo.utils;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class ReadExcelUtil {

    public static Map<String, String> getElementData() {
        Workbook wb;
        Sheet sheet;
        Row row;
        List<Map<String, String>> list = null;
        String cellData;
        Map<String, String> map = new LinkedHashMap<String, String>();
        wb = readExcel("locator/data.xlsx");
        if (wb != null) {
            sheet = wb.getSheetAt(0);
            int rownum = sheet.getPhysicalNumberOfRows();
            for (int i = 1; i < rownum; i++) {
                row = sheet.getRow(i);
                if (row != null) {
                    String name = (String) getCellFormatValue(row.getCell(0));
                    cellData = getCellFormatValue(row.getCell(1)) + "," + getCellFormatValue(row.getCell(2));
                    map.put(name, cellData);
                } else {
                    break;
                }
            }
        }
        return map;
    }

    public static Workbook readExcel(String filePath) {
        Workbook wb = null;
        if (filePath == null) {
            return null;
        }
        String extString = filePath.substring(filePath.lastIndexOf("."));
        InputStream is = null;
        try {
            is = new FileInputStream(filePath);
            if (".xls".equals(extString)) {
                return wb = new HSSFWorkbook(is);
            } else if (".xlsx".equals(extString)) {
                return wb = new XSSFWorkbook(is);
            } else {
                return wb = null;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return wb;
    }

    public static Object getCellFormatValue(Cell cell) {
        Object cellValue = null;
        if (cell != null) {
            switch (cell.getCellType()) {
                case Cell.CELL_TYPE_NUMERIC: {
                    cellValue = String.valueOf(cell.getNumericCellValue());
                    break;
                }
                case Cell.CELL_TYPE_FORMULA: {
                    if (DateUtil.isCellDateFormatted(cell)) {
                        cellValue = cell.getDateCellValue();
                    } else {
                        cellValue = String.valueOf(cell.getNumericCellValue());
                    }
                    break;
                }
                case Cell.CELL_TYPE_STRING: {
                    cellValue = cell.getRichStringCellValue().getString();
                    break;
                }
                default:
                    cellValue = "";
            }
        } else {
            cellValue = "";
        }
        return cellValue;
    }

}

可以在本地创建一个data.xlsx文件，保存在locator目录中，放在项目根目录下，通过调用getElementData方法，将解析后元素对象放到map中实现映射

读取配置文件config.properties,具体代码如下：

package com.frame.demo.utils;

import java.util.Locale;
import java.util.ResourceBundle;

public class BaseInfo {

    public static String getBrowserType() {
        return getInfo("browserType");
    }

    public static String getUrl() {
        return getInfo("url");
    }

    public static String getInfo(String key) {
        ResourceBundle bundle = ResourceBundle.getBundle("config", Locale.CHINA);
        String value = bundle.getString(key);
        return value;
    }
}

2.32、By对象的封装

在写脚本时，元素对象一般是这样写的 WebElement element = driver.findElement(By.name(value);,接下来我们要把excel解析出来的Map中的"value"转换成 By 对象，添加如下代码：

 private By getBy(String method, String methodValue) {
        if (method.equals("id")) {
            return By.id(methodValue);
        } else if (method.equals("name")) {
            return By.name(methodValue);
        } else if (method.equals("xpath")) {
            return By.xpath(methodValue);
        } else if (method.equals("className")) {
            return By.className(methodValue);
        } else if (method.equals("linkText")) {
            return By.linkText(methodValue);
        } else if (method.equals("css")) {
            return By.cssSelector(methodValue);
        } else {
            return By.partialLinkText(methodValue);
        }
    }

这样通过map中的key和 value 的值就对产生一个 By 对象，接着可以把这个对象传给 driver.findElement 方法，然后我们在进行WebElement 对象的封装

    private By getBy(String method, String methodValue) {
        if (method.equalsIgnoreCase("id")) {
            return By.id(methodValue);
        } else if (method.equalsIgnoreCase("name")) {
            return By.name(methodValue);
        } else if (method.equalsIgnoreCase("tagName")) {
            return By.tagName(methodValue);
        } else if (method.equalsIgnoreCase("className")) {
            return By.className(methodValue);
        } else if (method.equalsIgnoreCase("linkText")) {
            return By.linkText(methodValue);
        } else if (method.equalsIgnoreCase("xpath")) {
            return By.xpath(methodValue);
        } else if (method.equalsIgnoreCase("cssSelector")) {
            return By.cssSelector(methodValue);
        } else {
            return By.partialLinkText(methodValue);
        }
    }

    public WebElement findElement(String name) {
        String data = elementData.get(name).toString();
        String method = data.split(",")[0];
        String methodValue = data.split(",")[1];return driver.findElement(this.getBy(method, methodValue));
    }

这回再来看一下，是不是感觉有那么点意思了，代码整洁了许多，到这里一个简单的元素管理部分的实现就算基本完成了，这只是提供一个思路，来个总结性的代码。

package com.frame.demo.page;

import com.frame.demo.base.GetDriverUtil;
import com.frame.demo.utils.BaseInfo;
import com.frame.demo.utils.ReadExcelUtil;
import org.apache.log4j.Logger;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.PageFactory;

import java.util.Map;

public class BasePage {
    private static Logger logger = Logger.getLogger(BasePage.class);
    static WebDriver driver;
    Map<String, String> elementData;

    public BasePage() {
        String browserType = BaseInfo.getBrowserType();
        driver = GetDriverUtil.getDriver(browserType);
        driver.manage().window().maximize();
        PageFactory.initElements(driver, this);
        elementData = ReadExcelUtil.getElementData();
    }

    private By getBy(String method, String methodValue) {
        if (method.equalsIgnoreCase("id")) {
            return By.id(methodValue);
        } else if (method.equalsIgnoreCase("name")) {
            return By.name(methodValue);
        } else if (method.equalsIgnoreCase("tagName")) {
            return By.tagName(methodValue);
        } else if (method.equalsIgnoreCase("className")) {
            return By.className(methodValue);
        } else if (method.equalsIgnoreCase("linkText")) {
            return By.linkText(methodValue);
        } else if (method.equalsIgnoreCase("xpath")) {
            return By.xpath(methodValue);
        } else if (method.equalsIgnoreCase("cssSelector")) {
            return By.cssSelector(methodValue);
        } else {
            return By.partialLinkText(methodValue);
        }
    }

    public WebElement findElement(String name) {
        String data = elementData.get(name).toString();
        String method = data.split(",")[0];
        String methodValue = data.split(",")[1];
        logger.info("获取元素控件 " + name);
        return driver.findElement(this.getBy(method, methodValue));
    }

    public void switchToFrame(int frame) {
        driver.switchTo().frame(frame);
    }

    public void open() {
        String url = BaseInfo.getUrl();
        logger.info("打开163邮箱首页");
        driver.get(url);
    }

    public void quit() {
        logger.info("关闭浏览器成功！");
        driver.quit();
    }
}

整合了一部分driver对象的操作，仅供参考，有兴趣的同学可以接着拓展

2.4、元素对象层的再封装

接着我们再来创建一个类，名为Action继承BasePage，用于存放页面元素定位和常用控件操作的封装，具体示例代码如下：

package com.frame.demo.action;

import com.frame.demo.page.BasePage;

public class Action extends BasePage {

    public void sendKeys(String name, String str) {
        findElement(name).clear();
        findElement(name).sendKeys(str);
    }

    public void click(String name) {
        findElement(name).click();
    }

    public String getText(String name) {
        return findElement(name).getText();
    }
}

2.5、操作层的实现

接着我们再来创建一个类，名为LoginPage继承Action，用来记录登录的一系列操作，具体示例代码如下：

package com.frame.demo.object;

import com.frame.demo.action.Action;
import org.testng.Assert;
public class LoginPage extends Action {
    public void login(String userName, String pwd, String expected) throws Exception {
        open();
        click("密码登录");
        switchToFrame(0);
        sendKeys("输入用户名", userName);
        sendKeys("输入密码", pwd);
        click("点击登录");
        Thread.sleep(1000);
        String msg = getText("错误提示信息");
        Assert.assertEquals(msg, expected);
        quit();
    }
}

2.6、业务层的实现

最后我们再来创建一个类，名为TestFrame继承LoginPage，用来验证登录功能，具体示例代码如下：

package com.frame.demo.test;

import com.frame.demo.object.LoginPage;
import org.testng.annotations.Test;

public class TestFrame extends LoginPage {

    @Test
    public void textLogin() throws Exception {
       login("your userName", "your passWord", "帐号格式错误");
    }
}

到此基本可以说是，一个最简单的自动化测试框架算完成了一大半啦，是不是感觉很开心。哈哈

2.7、测试报告的美化

笔者之前用过testNG自带的测试报告、优化过reportNG的测试报告、Zreport(大飞总原创)，Allure2，这些是我之前都用过的，这里我想用extentreport做演示讲解，因为界面的dashboard很好看，毕竟始于颜值嘛，哈哈，好了，废话不多说。

具体步骤如下：

在maven项目pom.xml文件添加如下内容：

   <dependency>
            <groupId>com.relevantcodes</groupId>
            <artifactId>extentreports</artifactId>
            <version>2.41.1</version>
        </dependency>

        <dependency>
            <groupId>com.vimalselvam</groupId>
            <artifactId>testng-extentsreport</artifactId>
            <version>1.3.1</version>
        </dependency>

        <dependency>
            <groupId>com.aventstack</groupId>
            <artifactId>extentreports</artifactId>
            <version>3.0.6</version>
        </dependency>

然后新建一个类，名为ExtentTestngReporterListener，用来编写监听类，监听测试执行过程中哪些测试成功，哪些失败，写入报告中，具体示例代码如下：

package com.frame.demo.report;

import com.aventstack.extentreports.ExtentReports;
import com.aventstack.extentreports.ExtentTest;
import com.aventstack.extentreports.ResourceCDN;
import com.aventstack.extentreports.Status;
import com.aventstack.extentreports.model.TestAttribute;
import com.aventstack.extentreports.reporter.ExtentHtmlReporter;
import com.aventstack.extentreports.reporter.configuration.ChartLocation;
import org.testng.*;
import org.testng.xml.XmlSuite;

import java.io.File;
import java.util.*;

/**
 * @author rongrong
 */
public class ExtentTestngReporterListener implements IReporter {
    //生成的路径以及文件名
    private static final String OUTPUT_FOLDER = "test-output/";
    private static final String FILE_NAME = "index.html";
    private ExtentReports extent;

    @Override
    public void generateReport(List<XmlSuite> xmlSuites, List<ISuite> suites, String outputDirectory) {
        init();
        boolean createSuiteNode = false;
        if (suites.size() > 1) {
            createSuiteNode = true;
        }
        for (ISuite suite : suites) {
            Map<String, ISuiteResult> result = suite.getResults();
            //如果suite里面没有任何用例，直接跳过，不在报告里生成
            if (result.size() == 0) {
                continue;
            }
            //统计suite下的成功、失败、跳过的总用例数
            int suiteFailSize = 0;
            int suitePassSize = 0;
            int suiteSkipSize = 0;
            ExtentTest suiteTest = null;
            //存在多个suite的情况下，在报告中将同一个一个suite的测试结果归为一类，创建一级节点。
            if (createSuiteNode) {
                suiteTest = extent.createTest(suite.getName()).assignCategory(suite.getName());

            }
            boolean createSuiteResultNode = false;
            if (result.size() > 1) {
                createSuiteResultNode = true;
            }
            for (ISuiteResult r : result.values()) {
                ExtentTest resultNode;
                ITestContext context = r.getTestContext();
                if (createSuiteResultNode) {
                    //没有创建suite的情况下，将在SuiteResult的创建为一级节点，否则创建为suite的一个子节点。
                    if (null == suiteTest) {
                        resultNode = extent.createTest(r.getTestContext().getName());
                    } else {
                        resultNode = suiteTest.createNode(r.getTestContext().getName());
                    }
                } else {
                    resultNode = suiteTest;
                }
                if (resultNode != null) {
                    resultNode.getModel().setName(suite.getName() + " : " + r.getTestContext().getName());
                    if (resultNode.getModel().hasCategory()) {
                        resultNode.assignCategory(r.getTestContext().getName());
                    } else {
                        resultNode.assignCategory(suite.getName(), r.getTestContext().getName());
                    }
                    resultNode.getModel().setStartTime(r.getTestContext().getStartDate());
                    resultNode.getModel().setEndTime(r.getTestContext().getEndDate());
                    //统计SuiteResult下的数据
                    int passSize = r.getTestContext().getPassedTests().size();
                    int failSize = r.getTestContext().getFailedTests().size();
                    int skipSize = r.getTestContext().getSkippedTests().size();
                    suitePassSize += passSize;
                    suiteFailSize += failSize;
                    suiteSkipSize += skipSize;
                    if (failSize > 0) {
                        resultNode.getModel().setStatus(Status.FAIL);
                    }
                    resultNode.getModel().setDescription(String.format("Pass: %s ; Fail: %s ; Skip: %s ;", passSize, failSize, skipSize));
                }
                buildTestNodes(resultNode, context.getFailedTests(), Status.FAIL);
                buildTestNodes(resultNode, context.getSkippedTests(), Status.SKIP);
                buildTestNodes(resultNode, context.getPassedTests(), Status.PASS);
            }
            if (suiteTest != null) {
                suiteTest.getModel().setDescription(String.format("Pass: %s ; Fail: %s ; Skip: %s ;", suitePassSize, suiteFailSize, suiteSkipSize));
                if (suiteFailSize > 0) {
                    suiteTest.getModel().setStatus(Status.FAIL);
                }
            }

        }

        extent.flush();
    }

    private void init() {
        //文件夹不存在的话进行创建
        File reportDir = new File(OUTPUT_FOLDER);
        if (!reportDir.exists() && !reportDir.isDirectory()) {
            reportDir.mkdir();
        }
        ExtentHtmlReporter htmlReporter = new ExtentHtmlReporter(OUTPUT_FOLDER + FILE_NAME);
        htmlReporter.config().setDocumentTitle("自动化测试报告");
        htmlReporter.config().setReportName("自动化测试报告");
        htmlReporter.config().setChartVisibilityOnOpen(true);
        htmlReporter.config().setTestViewChartLocation(ChartLocation.TOP);
        htmlReporter.config().setResourceCDN(ResourceCDN.EXTENTREPORTS);
        htmlReporter.config().setCSS(".node.level-1  ul{ display:none;} .node.level-1.active ul{display:block;}");
        extent = new ExtentReports();
        extent.attachReporter(htmlReporter);
        extent.setReportUsesManualConfiguration(true);
    }

    private void buildTestNodes(ExtentTest extenttest, IResultMap tests, Status status) {
        //存在父节点时，获取父节点的标签
        String[] categories = new String[0];
        if (extenttest != null) {
            List<TestAttribute> categoryList = extenttest.getModel().getCategoryContext().getAll();
            categories = new String[categoryList.size()];
            for (int index = 0; index < categoryList.size(); index++) {
                categories[index] = categoryList.get(index).getName();
            }
        }

        ExtentTest test;

        if (tests.size() > 0) {
            //调整用例排序，按时间排序
            Set<ITestResult> treeSet = new TreeSet<ITestResult>(new Comparator<ITestResult>() {
                @Override
                public int compare(ITestResult o1, ITestResult o2) {
                    return o1.getStartMillis() < o2.getStartMillis() ? -1 : 1;
                }
            });
            treeSet.addAll(tests.getAllResults());
            for (ITestResult result : treeSet) {
                Object[] parameters = result.getParameters();
                String name = "";
                //如果有参数只取第一个参数作test-name
                for (int i = 0; i < parameters.length; i++) {
                    name = parameters[0].toString();
                }

                if (name.length() > 0) {
                    if (name.length() > 100) {
                        name = name.substring(0, 100) + "...";
                    }
                } else {
                    name = result.getMethod().getMethodName();
                }
                if (extenttest == null) {
                    test = extent.createTest(name);
                } else {
                    //作为子节点进行创建时，设置同父节点的标签一致，便于报告检索。
                    test = extenttest.createNode(name).assignCategory(categories);
                }
                for (String group : result.getMethod().getGroups()) {
                    test.assignCategory(group);
                }

                List<String> outputList = Reporter.getOutput(result);
                for (String output : outputList) {
                    //将用例的log输出报告中
                    test.debug(output);
                }
                if (result.getThrowable() != null) {
                    test.log(status, result.getThrowable());
                } else {
                    test.log(status, "Test " + status.toString().toLowerCase() + "ed");
                }
                //test.getModel().setStartTime(getTime(result.getStartMillis()));
                //test.getModel().setEndTime(getTime(result.getEndMillis()));
            }
        }
    }

    private Date getTime(long millis) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(millis);
        return calendar.getTime();
    }

}

在xml文件中设置监听

       <listener class-name="com.frame.demo.report.ExtentTestngReporterListener"/>

运行测试后，会自动生成测试报告，如下：

到此测试报告部分介绍完毕，现在整体的一个测试框架就算搭建完成了！！

整体运行效果：

总结

笔者仅是提供一个思路，希望感兴趣的同学可以从头到下自己敲一遍，笔者能力有限，还请勿喷，如果大家有更好的想法，还请在文末给我留言，一起学习交流！！

友情提示

原创不易，如转载或复制以上代码还请注明出处，觉得文章好，还请添加关注！

原文地址：https://www.cnblogs.com/longronglang/p/11400742.html

时间： 2024-10-07 02:04:19

Selenium+java - 手把手一起搭建一个最简单自动化测试框架的相关文章

如何搭建一个简易的Web框架

Web框架本质 什么是Web框架, 如何自己搭建一个简易的Web框架?其实, 只要了解了HTTP协议, 这些问题将引刃而解. 简单的理解:  所有的Web应用本质上就是一个socket服务端, 而用户的浏览器就是一个socket客户端. 用户在浏览器的地址栏输入网址, 敲下回车键便会给服务端发送数据, 这个数据是要遵守统一的规则(格式)的, 这个规则便是HTTP协议. HTTP协议主要规定了客户端和服务器之间的通信格式 浏览器收到的服务器响应的相关信息可以在浏览器调试窗口(F12键开启)的Net

如何搭建一个合理的数值框架

转自:http://www.gameres.com/749634.html 如何搭建一个合理的数值框架? 1.拍脑袋定下一系列的数值设定,完成所有数值框架的设定 2.数值检验,模拟计算重要参数,来确定数值框架是否合理 针对第一个要点,关键在于我们需要定哪些关键数值设定,以及如何来“拍” 针对第二个要点,关键在于我们需要哪些参数来验证数值框架是否合理,以及这些参数是否足以验证数值框架的合理性 一.我提出一些我们可能需要“拍”的数值设定 1.主线成长与付费成长比例 2.主线成长和付费成长分别包含了几

Dubbo入门---搭建一个最简单的Demo框架

Dubbo背景和简介 Dubbo开始于电商系统,因此在这里先从电商系统的演变讲起. 单一应用框架(ORM) 当网站流量很小时,只需一个应用,将所有功能如下单支付等都部署在一起,以减少部署节点和成本. 缺点:单一的系统架构,使得在开发过程中,占用的资源越来越多,而且随着流量的增加越来越难以维护 垂直应用框架(MVC) 垂直应用架构解决了单一应用架构所面临的扩容问题,流量能够分散到各个子系统当中,且系统的体积可控,一定程度上降低了开发人员之间协同以及维护的成本,提升了开发效率. 缺点:但是在垂直架构

搭建一个超级简单的spring框架

1.准备环境 (1)下载JDK.myEclipse.Tomcat,之后配置好相关的参数 备注:在myEclipse上配置Tomcat: 启动Tomcat服务后,在浏览器输入localhost:8080运行成功即表示配置成功 (2)新建一个Web Project 配置到Tomcat上 再次启动Tomcat,输入地址后,如果能运行成功即表示新建成功 2.前期准备 (1)首先下载所需要的jar包 下载地址: spring-framework-4.0.4.RELEASE-dist:http://repo

搭建appium+maven手机自动化测试框架

搭建安卓自动化测试框架记录: 需要的软件: jdk版本:jdk1.8 appium版本:v1.4.16 下载AppiumForWindows.zip adb:adt_bundle_windows_x86_20130917.467161976.rar,带Android SDK,eclipse,Android SDK Manager node.js:node-v5.7.0-x64.msi 1.jdk.Maven环境变量配置: 变量配置:JAVA_HOME    C:\Program Files\Ja

Selenium+Java+Chrome环境搭建

今天来讲一下自动化测试环境的搭建,整个过程分为四步,非常简单. 一.chrome浏览器安装 1.下载chrome浏览器并安装,下载路径网上很多. 2. 由于selenium只嵌入了firefox的驱动包,而不包含chrome,因此我们需要下载chrome浏览器对应版本的chromedriver,地址:http://npm.taobao.org/mirrors/chromedriver/:关于chrome版本及对应的driver该网址上有最新的说明文档,如下: 详情可自行翻阅查看,此处不再赘述.

通过Java Web Filter实现一个最简单的UrlRewrite过滤器

工具:支持JavaEE的Eclipse IDE Web 过滤器可以通过动态Web项目来直接添加:或者直接创建Java项目通过添加类来完成,参看如下过滤器代码: package me.ereach.urlfilter; import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.se

利用SpringCloud搭建一个最简单的微服务框架

http://blog.csdn.net/caicongyang/article/details/52974406 1.微服务 微服务主要包含服务注册,服务发现,服务路由,服务配置,服务熔断,服务降级等一系列的服务,而Spring Cloud为我们提供了个一整套的服务: 本例子为你提供了最简单的一个服务发现例子,包含服务注册发现spingCloudEurekaServer.服务配置中心spingCloudConfServer.以及一个app应用springCloudApp 2.服务注册与发现 s

一文秒懂如何搭建一个最简单的充值系统

? ???阅读完本文大概需要5分钟. 目录 移动支付 微信支付 支付宝支付 充值体系 最基础的架构 生产环境应用 总结 参考 ? ???一切都是生意."天下熙熙皆为利来,天下攘攘皆为利往".不知从什么时候起,人类社会诞生了公司这样的组织,而这个组织把人们结合在一起,产生了各种行业和商业形态,最后,公司的一切活动都变成了生意.当然,大公司有大公司的生意,小公司有小公司的买卖. ? ???过去几年saas服务软件大行其道,这其中就有大家熟悉的阿里云服务,客户注册账户+线上支付就能使用软件.