velocity笔记（一）什么是velocity，我们什么时候会使用到这个,基本语法,利用模板生成实体类的各层代码

一写代码就开心

发布于 2022-05-09 09:52:56

9400

发布于 2022-05-09 09:52:56

文章被收录于专栏： java和python

什么是velocity
应用场景
组成结构
快速入门
- 总结
基本语法
- 注释
- 非解析内容
- 引用
  - 变量引用
  - 属性引用
  - 方法引用
- 指令
  - 流程控制指令
    - #set 指令
    - #if/#elseif/#else
    - #foreach
  - 引入资源指令
    - include
    - parse
    - define
    - evaluate
  - 宏指令
综合案例
- 需求分析
- 步骤分析
- 代码实现
  - controller模板
  - service 模板
  - serviceimpl 模板
  - mapper 模板
  - 公共方法
  - 测试类

什么是velocity

也就是前端程序员写velocity模板，后端程序员写数据模型，最后整合就是展示给用户的东西

应用场景

组成结构

快速入门

以上就是创建了一个maven项目

我们要在项目中使用velocity，所以要导入对应的依赖

    <dependencies>
<!--        velocity  的核心包-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.2</version>
        </dependency>

<!--        进行单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

    </dependencies>

以上是导入依赖。现在开始创建模板，这个模块在什么地方都可以，最后只要路径对了就可以，我们习惯放到resources文件夹下

以上先创建一个HTML模板，之后修改这个文件的后缀，变为vm

以上是最简单的语法。

之后我们要写测试类，里面调用这个vm文件，将数据写到这个vm里面

public class quickstart {

    @Test
    public void test1() throws IOException {

//        1  设置velocity 的资源加载器


        Properties properties = new Properties();
//        固定的写法
        properties.put("file.resource.loader.class","org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
//        2 初始化velocity引擎
        Velocity.init(properties);

//        3  创建velocity的容器
        VelocityContext velocityContext = new VelocityContext();
//        这个容器里面要放一些数据
        velocityContext.put("name","jing");
//        4 加载velocity的模板文件
        Template template = Velocity.getTemplate("vms/01-quickstart.vm", "utf-8");


//        5  合并数据到模板
        FileWriter fileWriter = new FileWriter("D:\\javacode\\velocity_01\\src\\main\\resources\\html\\01quick.html");
        template.merge(velocityContext,fileWriter);

//        6  释放资源
        fileWriter.close();

    }
}

执行完以上的语句，那么在新的文件夹下，就会生成一个HTML文件

总结

就是前端写velocity模板，后端写代码，将数据填充到模板里面，生成HTML文件

以后就是填充的内容需要是动态的，使用的模板是动态的，输出的HTML的路径是动态的，其他的都是固定的。

基本语法

也就是根据这些语法，我们可以将在context里面的内容填充到模板中

注释

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
## 这个是单行注释

#*
* 这个是多行注释
*
* *#

#**
*   这个是文档注释
* *#


你好，${name},我是好人
</body>
</html>

在vm文件里面，写的注释，最后生成HTML文件，是不会出现在HTML里面的，但是会用空区域代替有注释的地方，在HTML里面会有很多的空区域

非解析内容

也就是在模板里面写的什么，最后在HTML里面就会展示什么

引用

变量引用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


<h1>引用变量</h1>

常规语法：$name11
正规语法：${name11}


常规语法：  $!name11
正规语法 ：  $!{name11}



</body>
</html>

属性引用

也就是变量是一个对象，我们想要对象里面的属性，所以这个就是属性引用

方法引用

指令

流程控制指令

#set 指令

模板

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
$user.username  ---  $user.password

$str.split(" ")
$now.getTime()

## 定义变量
#set($str = "hello")
#set($int = 10)
#set($arr = ["10","12"])
#set($boolean = true)
#set($map = {"key1":"values"})

#set($name = "jing")
#set($strt = "你好 $name")

## 获取变量

$str
$int
$arr
$boolean
$map.key1
$name
$strt


</body>
</html>

生成的HTML

#if/#elseif/#else

模板

#set($language = "java")

#if($language.equals("java"))
java
#elseif($language.equals("python"))
    python
#end

生成的HTML

#foreach

在velocity里面存放list数据

        ArrayList<String> strings = new ArrayList<>();
        strings.add("152");
        strings.add("452");
        strings.add("8566");
        String[]  hobbi = new String[]{"ddd","888","8888"};
        velocityContext.put("strings",strings);
        velocityContext.put("hobbi",hobbi);

在模板里面进行遍历

#foreach($item in $hobbi)
    $item
#end

#foreach($item in $strings)
    $item
#end

引入资源指令

include

#include("/vms/01-quickstart.vm")

都没有被解析，直接将引入的模板的里面的东西给复制过来了

parse

#parse("/vms/01-quickstart.vm")

define

这个就是定义在这个里面的语法，其他的地方就可以使用

evaluate

#evaluate("#if($user.username == 'liujing' )  liuj #else jjj
#end")

宏指令

和 define指令比较，这个是动态的，意思是里面可以拿出变量里面的值

综合案例

需求分析

步骤分析

代码实现

创建一个ssm项目或者springboot项目，可以实现对数据库的增删改查的项目就可以了，把velocity的依赖也导入

因为我们要生成以上的几层的数据，所以每一层我们都要写一个模板

controller模板

因为是模板，所以controller的前面的东西我们不写，现在我们建立了这个文件，里面开始写controller层的模板

package ${package}.controller;

import ${package}.pojo.${className};
import ${package}.service.${className}Service;



##  每个里面都要有
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Map;

/**
 * @author jing
 * @date 2020/11/23--12:00
 * 一审信息
 */

@Controller
@RequestMapping(value = "/${classname}",method = RequestMethod.POST)
public class ${className}Controller {
    @Autowired
    private ${className}Service ${classname}Service;


    /**
    * 查询列表
    * @param
    * @return
    */
    @RequestMapping("/${classname}list")
    @ResponseBody
    public List<${className}> ${classname}list(){
        List<${className}>  ${classname}s  = null;
        try {
                ${classname}s = ${classname}Service.list();

            return ${classname}s;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }






    /**
     * @author
     * @date
     * 保存
     */
    @RequestMapping("/add${classname}")
    @ResponseBody
    public String add${classname}(${className}  ${classname}){
        try {
            ${classname}Service.save(${classname});
            return "1";
        } catch (Exception e) {
            e.printStackTrace();
            return "0";
        }

    }





    /**
     * 修改
     * @param
     * @return
     */
    @RequestMapping("/update${className}")
    @ResponseBody
    public String update${className}( ${className}  ${classname}){
        try {
            ${className}Service.update(${classname});
            return "1";
        } catch (Exception e) {
            e.printStackTrace();
            return "0";
        }
    }
}

service 模板

package ${package}.service;

import ${package}.pojo.${className};

import java.util.List;

public interface ${className}Service {
    //查询所有的用户信息
    List<${className}> list();
##    保存数据
    void save(${className} ${classname});
##    更新数据
    void update(${className} ${classname});
}

serviceimpl 模板

package ${package}.service.impl;


import ${package}.mapper.${className}Mapper;
import ${package}.pojo.${className};
import ${package}.service.${className}Service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @Transactional:
 *  此注解的作用是开启事务管理，相当于我们以前在applicationcontext.xml
 *  文件中配置的事务管理。
 */
@Transactional
@Service
public class ${className}ServiceImpl implements ${className}Service {
    //声明mapper层属性
    @Autowired
    private ${className}Mapper ${classname}Mapper;

##  查询list
    @Override
    public List<${className}> list() {
        return ${classname}Mapper.list();
    }

## 保存
    @Override
    public void save(${className}  ${classname}) {
        return ${classname}Mapper.save(${classname});
    }


##    更新
    @Override
    public void update(${className}  ${classname}) {
        return ${classname}Mapper.update(${classname});
    }
}

mapper 模板

package ${package}.mapper;

import ${package}.pojo.${className};

import java.util.List;

public interface ${className}Mapper {
    //查询所有的用户信息
    List<${className}> list();
##    保存数据
    void save(${className} ${classname});
##    更新数据
    void update(${className} ${classname});
}

公共方法

我们已经写完了模板，现在开始写一个公共方法，就是我们代码生成的路径，也就是用这些模板，生成的java文件，我们要放到哪里

public class GenUtils {

    /**
     * @param  date    填充到模板中的数据
     * @param  templates   模板的名称
     * @param  zip  输出流
     * @date 2021/8/25--22:01
     */

    public  static  void  generatorCode(Map<String,Object> date, List<String> templates, ZipOutputStream zip){

//        1  设置velocity 的资源加载器
        Properties properties = new Properties();
//        固定的写法
        properties.put("file.resource.loader.class","org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
//        2 初始化velocity引擎
        Velocity.init(properties);
//        3  创建velocity的容器  这个容器里面要放一些数据
        VelocityContext velocityContext = new VelocityContext(date);
//        4 加载velocity的模板文件（因为有多个，所以要遍历）
        for(String tem:templates){
            Template template = Velocity.getTemplate(tem, "utf-8");
//            5  合并数据到模板
//            创建一个输出流
            StringWriter stringWriter = new StringWriter();
//            将数据放到输出流里面
            template.merge(velocityContext,stringWriter);
//            把代码数据输出到zip文件里面
            String fileName = getFileName(tem, date.get("className").toString(), date.get("package").toString());
            try {
                zip.putNextEntry(new ZipEntry(fileName));

                IOUtils.write(stringWriter.toString(),zip,"UTF-8");
                IOUtils.closeQuietly(stringWriter);
            } catch (IOException e) {
                e.printStackTrace();
            }


        }



    }










    /**
     * @param  template  模板名称，也就是我们要使用哪个模板生成java文件
     * @param  className  实体类名称  User
     * @param  packageName  包名称  在哪个包下生成
     * @date 2021/8/25--22:01
     * @return  main/java/com/controller/UserController.java
     * main/java/com/service/UserService.java
     * main/java/com/service/impl/UserServiceimpl.java
     * main/java/com/mapper/UserMapper.java
     */

    public static String  getFileName(String template,String className,String packageName){
        String packagePath = "main"+ File.separator +"java"+ File.separator;

//        如果包名不为空，我们在基础路径上，拼接这个包名
        if(StringUtils.isNullOrEmpty(packageName)){
            packagePath+= packageName.replace(".",File.separator)+File.separator;
        }
//        看传进来的是什么模板，根据不同模板，拼接不同的路径
        if(template.contains("Controller.java.vm")){
            return packagePath+"controller"+File.separator+className+"Controller.java";
        }
        if(template.contains("Service.java.vm")){
            return packagePath+"service"+File.separator+className+"Service.java";
        }
        if(template.contains("ServiceImpl.java.vm")){
            return packagePath+"service"+File.separator+"impl"+File.separator+className+"Serviceimpl.java";
        }
        if(template.contains("Mapper.java.vm")){
            return packagePath+"mapper"+File.separator+className+"Mapper.java";
        }

        return null;

    }

    public static void main(String[] args) {
        String fileName = getFileName("Controller.java.vm","User","com");
        System.out.println(fileName);
    }







}

测试类

package com;

import com.sun.org.apache.bcel.internal.generic.NEW;
import com.utils.GenUtils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.zip.ZipOutputStream;

/**
 * @author 
 * @date 2021/8/25--22:38
 */
public class testy {

    public static void main(String[] args) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("package","com");
        map.put("className","Student");
        map.put("classname","student");

        ArrayList<String> strings = new ArrayList<>();
        strings.add("vm/Controller.java.vm");
        strings.add("vm/Mapper.java.vm");
        strings.add("vm/Service.java.vm");
        strings.add("vm/ServiceImpl.java.vm");

        File file = new File("D:\\data\\code.zip");
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            ZipOutputStream zipOutputStream = new ZipOutputStream(fileOutputStream);
            GenUtils.generatorCode(map,strings,zipOutputStream);
            try {
                zipOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }


    }
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2021-08-24，如有侵权请联系 cloudcommunity@tencent.com 删除

html

编程算法

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

html

编程算法

登录后参与评论

0 条评论

热度