動手搭建后端框架-Velocity模板引擎的應用

villainhr 發布于2019-08-19 11:46 / 3093人閱讀

摘要：目錄建造者模式應用。其實不用也可以，因為不是很復雜，只是為了復習一下所學過的設計模式知識目錄工廠模式應用。

為了提高開發效率，通常會想辦法把一些模式固定的重復性的勞動抽取出來，以后再使用的時候，拿來主義就可以了。這樣既可以提高開發效率，又降低了出錯的風險。

這一思想在我們的日常工作中可以說隨處可見，我們完成一項復雜的工程，并不需要面面俱到什么都自己寫，我們完全可以利用第三方的jar包讓我們達到事半功倍的效果，比如經常使用的apche的commons-lang3包。再比如java中的繼承、我們自己封裝的工具類等等。另外一方面，對于源碼文件，如果公司有成熟的框架，我們的開發都是遵循著框架制定的約定來進行開發的，我們在創建某一個業務的控制層、業務層、持久層的時候，實際上有相當一部分的工作是重復的。

那么對于源碼文件的編寫我們能否偷偷懶呢？答案肯定是可以的，我們可以利用模板引擎技術，將不變的部分寫在模板文件中，將可變的部分作為變量傳遞到模板引擎的上下文中，最終生成我們想要的源碼文件。

模板引擎的產品有很多，比如前端模板artTemplate、后端模板Velocity、FreeMarker等本文以Velocity為例，總結一下它在實戰中的應用

1.基礎知識

搭建過程涉及到的基礎知識包括：Maven、Velocity、工廠模式、建造者模式、單元測試
對于基礎不熟悉的同學，建議看一下下面的兩篇文章
Velocity基礎
Velocity語法摘要

2.搭建工程 2.1模塊目錄

代碼生成功能，在我設計的后臺框架中，作為一個獨立的模塊存在，使用Maven構建。
builder目錄：建造者模式應用。由于代表表結構的Table實體稍顯復雜，因此使用了建造者模式構建Table對象。其實不用也可以，因為Table不是很復雜，只是為了復習一下所學過的設計模式知識
factory目錄：工廠模式應用。在構建源碼文件的時候，由于涉及到了Controller、Service、Dao、Domain這幾種類型的文件，因此針對不同類型的文件，要使用其對應的處理類，因此使用了工廠模式
handler目錄：生成源文件的核心代碼
model目錄：在生成domain的時候，由于字段需要從數據庫中的表中讀取，因此構造了與表對應的實體類方便處理
utils目錄：工具類
Generator.java：程序主文件，調用入口
test目錄：單元測試

.
├── generator.iml
├── pom.xml
└── src
    ├── main
    │?? ├── java
    │?? │?? └── com
    │?? │??     └── wt
    │?? │??         └── master
    │?? │??             └── generator
    │?? │??                 ├── Generator.java
    │?? │??                 ├── builder
    │?? │??                 │?? ├── MySqlTableBuilder.java
    │?? │??                 │?? └── TableBuilder.java
    │?? │??                 ├── factory
    │?? │??                 │?? └── GeneratorFactory.java
    │?? │??                 ├── handler
    │?? │??                 │?? ├── BaseGenerator.java
    │?? │??                 │?? ├── ControllerGeneratorHandler.java
    │?? │??                 │?? ├── DomainGeneratorHandler.java
    │?? │??                 │?? ├── MapperGeneratorHandler.java
    │?? │??                 │?? └── ServiceGeneratorHandler.java
    │?? │??                 ├── model
    │?? │??                 │?? └── Table.java
    │?? │??                 └── util
    │?? │??                     ├── JdbcUtils.java
    │?? │??                     ├── SpringContextUtils.java
    │?? │??                     ├── TableColumnUtils.java
    │?? │??                     └── TableInfoUtils.java
    │?? └── resources
    │??     ├── config
    │??     │?? ├── applicationContext.xml
    │??     │?? └── db.properties
    │??     └── template
    │??         ├── controller.java.vm
    │??         ├── dao.java.vm
    │??         ├── domain.java.vm
    │??         ├── service.java.vm
    │??         └── serviceimpl.java.vm
    └── test
        └── com.wt.master.generator
            └── GeneratorTest.java

2.2引入依賴



    
        j2ee
        com.wt.master
        1.0-SNAPSHOT
        ../version/
    
    4.0.0

    generator
    
        
        
            org.apache.velocity
            velocity
            1.7
        
        
        
            junit
            junit
            4.12
            test
        
        
            com.wt.master
            core
            1.0-SNAPSHOT
        
        
        
            com.mchange
            c3p0
            0.9.5.4

3.核心代碼 3.1模板文件的定義

以controller層生成模板為例
將不變的部分直接寫到.vm文件中
將模板文件中，有可能發生變化的部分，抽取為變量，變量的值從VelocityContext中獲取
在Velocity架構中，有一個上下文的定義，通過上下文，程序將變量放入上下文對象中。而模板從上下文中獲取對應變量的值，獲取的方式是${變量名}，關于Velocity模板文件中的語法，參見上文提到的兩篇文章

package ${packagePath}.controller;

import ${packagePath}.domain.${moduleName};
import ${packagePath}.service.${moduleName}Service;
import com.wt.master.core.base.BaseController;
import com.wt.master.core.helper.QueryHelper;
import com.wt.master.core.request.HttpResultEntity;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * ${moduleNameCN}控制器
 *
 * @author
 * @date
 */
@Api(value = "${moduleNameCN}控制器", tags = "${moduleName}Controller", description = "${moduleNameCN}控制器" )
@RestController
@RequestMapping("/${moduleName}" )
@Slf4j
public class ${moduleName}Controller extends BaseController<${moduleName}, ${moduleName}Service> {
    @Autowired
    private ${moduleName}Service ${lowerModuleName}Service;

    @Override
    protected ${moduleName}Service getService() {
        return ${lowerModuleName}Service;
    }

}

3.2工廠類定義

根據源碼文件類型的不同，定義了不同的處理類，通過工廠模式返回對應的處理類

package com.wt.master.generator.factory;

import com.wt.master.generator.Generator;
import com.wt.master.generator.handler.*;

/**
 * 生成器工廠
 *
 * @author lichking2019@aliyun.com
 * @date Jun 18, 2019 at 4:02:23 PM
 */
public class GeneratorFactory {
    public static BaseGenerator create(Generator.GenerateItem item) {
        BaseGenerator baseGenerator = null;
        switch (item) {
            case service:
                baseGenerator = new ServiceGeneratorHandler();
                break;
            case controller:
                baseGenerator = new ControllerGeneratorHandler();
                break;
            case mapper:
                baseGenerator = new MapperGeneratorHandler();
                break;
            case domain:
                baseGenerator = new DomainGeneratorHandler();
                break;
            default:
                baseGenerator = new ControllerGeneratorHandler();
        }
        return baseGenerator;
    }
}

3.3源碼生成處理類定義

以controller處理類為例
定義抽象類，作為基類
定義了抽象方法generate，生成源碼文件的處理方法
定義了抽象方法getFilePath，獲取生成文件的路徑
方法的實現由具體的實現類來實現

package com.wt.master.generator.handler;

import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.runtime.RuntimeConstants;
import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;

/**
 * 生成器抽象
 *
 * @author lichking2019@aliyun.com
 * @date May 12, 2019 at 10:44:53 AM
 */
public abstract class BaseGenerator {
    /**
     * 生成代碼
     *
     * @param tableName    表名
     * @param moduleName   模塊英文名
     * @param moduleNameCN 模塊中文名
     * @param packagePath  包路徑
     * @return
     */
    public abstract BaseGenerator generate(String tableName, String moduleName, String moduleNameCN,
                                           String packagePath);

    /**
     * 生成文件路徑
     * @param packagePath
     * @return
     */
    public abstract String getFilePath(String packagePath,String moduleName);

    /**
     * 獲取 模板
     *
     * @param templateName 模板文件名稱
     * @return
     */
    Template getTemplate(String templateName) {
        VelocityEngine ve = new VelocityEngine();
        ve.setProperty(RuntimeConstants.RESOURCE_LOADER, "classpath" );
        ve.setProperty("classpath.resource.loader.class", ClasspathResourceLoader.class.getName());
        ve.setProperty("input.encoding","utf-8");
        ve.setProperty("output.encoding","utf-8");
        ve.init();
        Template t = ve.getTemplate("/template/" + templateName);
        return t;
    }

    protected void merge(Template template, VelocityContext ctx, String path) {
        File file = new File(path);
        if(!file.exists()){
            new File(file.getParent()).mkdirs();
        }else{
            System.out.println("替換文件"+file.getAbsolutePath());
        }

        PrintWriter writer = null;
        try {
            writer = new PrintWriter(path);
            template.merge(ctx, writer);
            writer.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            writer.close();
        }
    }

    /**
     * 獲得根目錄
     * @return
     */
    protected String getRootPath(){
        String rootPath = "";
        try {
            File file = new File(BaseGenerator.class.getResource("/").getFile());
            rootPath = file.getParent();
            rootPath = java.net.URLDecoder.decode(rootPath.substring(0, rootPath.indexOf("target") - 1), "utf-8");
            return rootPath+"/src/main/java";
        } catch (Exception e) {
            e.printStackTrace();
        }
        return rootPath;
    }

    /**
     * 轉換包路徑為文件路徑
     * @param packagePath
     * @return
     */
    protected String convertPackagePathToFilePath(String packagePath){
        StringBuilder path = new StringBuilder();
        path.append("/" );
        path.append(packagePath.replace(".", "/" ));
        path.append("/");
        return path.toString();
    }

}

3.4工具類的定義

該類主要是獲取表的信息及對應的字段信息

package com.wt.master.generator.util;

import com.wt.master.generator.model.Table;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.util.CollectionUtils;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 表操作類
 *
 * @author lichking2019@aliyun.com
 * @date Apr 23, 2019 at 11:36:30 PM
 */
public class TableInfoUtils {

    public static final String JDBC_TEMPLATE = "jdbcTemplate";

    public static Table getTableColumnList(String tableName) {
        JdbcTemplate jdbcTemplate = (JdbcTemplate) SpringContextUtils.getBean(JDBC_TEMPLATE);

        List> tableInfo = jdbcTemplate.queryForList(getTableStructureSql(tableName));
        if (CollectionUtils.isEmpty(tableInfo)) {
            throw new RuntimeException("表：" + tableName + "不存在" );
        }

        List> columns = jdbcTemplate.queryForList(getColumnStructureSql(tableName));

        return TableColumnUtils.convertToColumn(columns, tableInfo.get(0));
    }

    /**
     * 獲取查詢表字段屬性的SQL
     *
     * @param tableName 表名
     * @return
     */
    private static String getColumnStructureSql(String tableName) {
        StringBuilder sql = new StringBuilder();
        sql.append("select column_name, data_type,column_comment,column_key " );
        sql.append("from information_schema.columns " );
        sql.append("where table_name = "" + tableName + """ );
        return sql.toString();
    }

    /**
     * 獲取表的信息
     * @param tableName
     * @return
     */
    private static String getTableStructureSql(String tableName) {
        StringBuilder sql = new StringBuilder();
        sql.append("select table_name,table_comment " );
        sql.append("from information_schema.tables " );
        sql.append("where table_name= "" + tableName + """ );
        return sql.toString();
    }


}

3.5應用入口

代用create方法來生成源碼文件

package com.wt.master.generator;

import com.wt.master.generator.builder.MySqlTableBuilder;
import com.wt.master.generator.builder.TableBuilder;
import com.wt.master.generator.factory.GeneratorFactory;
import com.wt.master.generator.handler.BaseGenerator;
import com.wt.master.generator.model.Table;
import com.wt.master.generator.util.TableInfoUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.util.Assert;

import java.util.List;

/**
 * 代碼生成工具
 *
 * @author lichking2019@aliyun.com
 * @date Apr 23, 2019 at 10:41:51 PM
 */
public class Generator {

    /**
     * 生成代碼入口
     *
     * @param tableName    表名
     * @param moduleName   模塊英文名
     * @param moduleNameCN 模塊中文名
     * @param packagePath  打包路徑
     * @param item         生成項目
     */
    public static void create(String tableName, String moduleName, String moduleNameCN, String packagePath,
                              GenerateItem... item) {
        if (StringUtils.isBlank(tableName) || StringUtils.isBlank(moduleName) || StringUtils.isBlank(moduleNameCN) || StringUtils.isBlank(packagePath)) {
            throw new IllegalArgumentException("參數非法！" );
        }

        for (GenerateItem generateItem : item) {
            BaseGenerator baseGenerator = GeneratorFactory.create(generateItem);
            baseGenerator.generate(tableName, moduleName, moduleNameCN, packagePath);
        }
    }


    public enum GenerateItem {
        controller, service, mapper, domain
    }

}

4.單元測試

package com.wt.master.generator;

import org.junit.Test;
import org.junit.Before;
import org.junit.After;

/**
 * Generator Tester.
 *
 * @author 
 * @version 1.0
 * @since Jun 18, 2019
 */
public class GeneratorTest {
    @Test
    public void testCreate() throws Exception {
        //TODO: Test goes here...
        Generator.create("SecurityRoleT", "SecurityRole", "角色管理", "com.wt.common.security",
                Generator.GenerateItem.controller, Generator.GenerateItem.service, Generator.GenerateItem.mapper,
                Generator.GenerateItem.domain);
    }
}

源碼github地址

GPU云服務器云服務器開發框架的搭建后端框架后端開發框架 web后端框架

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/77841.html

結合Spring發送郵件的四種正確姿勢，你知道幾種？

摘要：我拿網易郵箱賬號舉例子，那么我們如何才能讓你的郵箱賬號可以利用第三方發送郵件這里的第三方就是我們即將編寫的程序。一前言測試所使用的環境測試使用的環境是企業主流的SSM 框架即 SpringMVC+Spring+Mybatis。為了節省時間，我直接使用的是我上次的SSM項目中整合Echarts開發該項目已經搭建完成的SSM環境。標題說的四種姿勢指的是哪四種姿勢？發送text...

doodlewind 2019-08-19 10:55 評論0 收藏0
Java 程序員必備的 15 個框架，前 3 個地位無可動搖！

摘要：官網源碼推薦從開始手寫一個框架更多請在技術棧微信公眾號后臺回復關鍵字。是一個開放源代碼的對象關系映射框架，它對進行了非常輕量級的對象封裝，它將與數據庫表建立映射關系，是一個全自動的框架。 Java 程序員方向太多，且不說移動開發、大數據、區塊鏈、人工智能這些，大部分 Java 程序員都是 Java Web/后端開發。那作為一名 Java Web 開發程序員必須需要熟悉哪些框架呢？今天...

galaxy_robot 2019-08-16 13:37 評論0 收藏0
工具集核心教程 | 第四篇： Velocity模板引擎入門到進階

摘要：是一個基于的模板引擎。模板中未被定義的變量將被認為是一個字符串。公眾號回復全棧，領取前端，，產品經理，微信小程序，等資源合集大放送。公眾號回復面試，領取面試實戰學習資源。 Velocity是一個基于java的模板引擎（template engine）。它允許任何人僅僅簡單的使用模板語言（template language）來引用由java代碼定義的對象。當Velocity應用于web...

leon 2019-08-19 11:38 評論0 收藏0
5分鐘搭建私人Java博客系統——Tale

摘要：你只需要花分鐘，就能擁有一個屬于自己的私人博客了，并且可以對整個項目有一個完成的概念和感覺。指令和相似，表達式和保持一致，易學易用。本文適合剛學習完 Java 語言基礎的人群，跟著本文可了解和運行 Tale 項目。示例均在 Windows 操作系統下演示 showImg(https://segmentfault.com/img/bVbwsbo?w=1578&h=868); 本文作者：...

null1145 2019-08-19 10:32 評論0 收藏0