也就是前端程序员写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>
也就是变量是一个对象,我们想要对象里面的属性,所以这个就是属性引用
模板
<!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
模板
#set($language = "java")
#if($language.equals("java"))
java
#elseif($language.equals("python"))
python
#end
生成的HTML
在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("/vms/01-quickstart.vm")
都没有被解析,直接将引入的模板的里面的东西给复制过来了
#parse("/vms/01-quickstart.vm")
这个就是 定义在这个里面的语法,其他的地方就可以使用
#evaluate("#if($user.username == 'liujing' ) liuj #else jjj
#end")
和 define指令比较,这个是动态的,意思是里面可以拿出变量里面的值
创建一个ssm项目 或者springboot项目,可以实现对数据库的增删改查的项目就可以了,把velocity的依赖也导入
因为我们要生成以上的几层的数据,所以每一层我们都要写一个模板
因为是模板,所以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";
}
}
}
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});
}
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});
}
}
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();
}
}
}