动手搭建后端框架-Velocity模板引擎的应用

villainhr 发布于2019-08-19 11:46 / 3235人阅读

摘要：目录建造者模式应用。其实不用也可以，因为不是很复杂，只是为了复习一下所学过的设计模式知识目录工厂模式应用。

为了提高开发效率，通常会想办法把一些模式固定的重复性的劳动抽取出来，以后再使用的时候，拿来主义就可以了。这样既可以提高开发效率，又降低了出错的风险。

这一思想在我们的日常工作中可以说随处可见，我们完成一项复杂的工程，并不需要面面俱到什么都自己写，我们完全可以利用第三方的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后端框架

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/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