代码生成_Mybatis

最新推荐文章于 2025-04-30 15:13:13 发布

原创最新推荐文章于 2025-04-30 15:13:13 发布 · 118 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#mybatis代码生成

代码生成专栏收录该内容

3 篇文章

订阅专栏

博客介绍了MyBatis代码生成相关内容，包含依赖pom.xml、配置文件（数据库配置和基本配置）以及配置源码（实体类、工具类和主方法），为MyBatis代码生成提供了详细的配置指引。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码生成_Mybatis

依赖pom.xml
配置文件
- 数据库配置
- 基本配置
配置源码

依赖pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.plxc.generator</groupId>
	<artifactId>code_generator</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<dependencies>
		<!-- https://mvnrepository.com/artifact/commons-configuration/commons-configuration -->
		<dependency>
			<groupId>commons-configuration</groupId>
			<artifactId>commons-configuration</artifactId>
			<version>1.10</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.apache.velocity/velocity -->
		<dependency>
			<groupId>org.apache.velocity</groupId>
			<artifactId>velocity</artifactId>
			<version>1.7</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/org.apache.velocity/velocity-tools -->
		<dependency>
			<groupId>org.apache.velocity</groupId>
			<artifactId>velocity-tools</artifactId>
			<version>2.0</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>2.4</version>
		</dependency>
		<dependency>
			<groupId>c3p0</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.1.1</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
		<dependency>
			<groupId>commons-dbutils</groupId>
			<artifactId>commons-dbutils</artifactId>
			<version>1.6</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.32</version>
		</dependency>
	</dependencies>

</project>

配置文件

数据库配置

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
	<!-- 默认配置，如果没有指定则使用这个配置 -->
	<default-config>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/shop</property>
		<property name="user">root</property>
		<property name="password">root</property>
	</default-config>

	<!-- 自定义配置 -->
	<named-config name="dataSource">
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/shop</property>
		<property name="user">root</property>
		<property name="password">qwe123</property>

		<!-- 初始化时创建的连接数 default:3 -->
		<property name="initialPoolSize">3</property>
		<!-- 连接的最大空闲时间，如果超过这个时间，某个数据库连接还没有被使用，则会断开掉这个连接，如果为0，则永远不会断开连接，default:0 单位：秒 -->
		<property name="maxIdleTime">0</property>
		<!-- 连接池中拥有的最大连接数，如果获得新连接时会使连接总数超过这个值则不会再获取新连接，而是等待其他连接释放，所以这个值有可能会设计地很大 default:15 -->
		<property name="maxPoolSize">15</property>
		<!-- 连接池保持的最小连接数 default:3 -->
		<property name="minPoolSize">3</property>
		<!-- 连接池在无空闲连接可用时一次性创建的新数据库连接数 default:3 -->
		<property name="acquireIncrement">3</property>
	</named-config>
	
	<named-config name="51zan">
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://192.168.0.144:3306/demo</property>
		<property name="user">dev</property>
		<property name="password">qwe123</property>

		<!-- 初始化时创建的连接数 default:3 -->
		<property name="initialPoolSize">3</property>
		<!-- 连接的最大空闲时间，如果超过这个时间，某个数据库连接还没有被使用，则会断开掉这个连接，如果为0，则永远不会断开连接，default:0 单位：秒 -->
		<property name="maxIdleTime">0</property>
		<!-- 连接池中拥有的最大连接数，如果获得新连接时会使连接总数超过这个值则不会再获取新连接，而是等待其他连接释放，所以这个值有可能会设计地很大 default:15 -->
		<property name="maxPoolSize">15</property>
		<!-- 连接池保持的最小连接数 default:3 -->
		<property name="minPoolSize">3</property>
		<!-- 连接池在无空闲连接可用时一次性创建的新数据库连接数 default:3 -->
		<property name="acquireIncrement">3</property>
	</named-config>
</c3p0-config>

基本配置

#代码生成器，配置信息


package=com.plxc.common.po.user
author=Vander
#表前缀(类名不会包含表前缀)
tablePrefix=t_

#需要生产代码的表，多个以;隔开
tables=t_role

#类型转换，配置信息
tinyint=Integer
smallint=Integer
mediumint=Integer
int=Integer
integer=Integer
bigint=Long
float=Float
double=Double
decimal=BigDecimal

char=String
varchar=String
tinytext=String
text=String
mediumtext=String
longtext=String

date=Date
datetime=Date
timestamp=Date

配置源码

实体类

package com.plxc.generator.red.entity;

/**
 * @Description:列的属性
 * @author vander
 * @Date 2017/5/11
 */
public class ColumnEntity {
	// 列名
	private String columnName;
	// 列名类型
	private String dataType;
	// 列名备注
	private String comments;

	// 属性名称(第一个字母大写)，如：user_name => UserName
	private String attrName;
	// 属性名称(第一个字母小写)，如：user_name => userName
	private String attrname;
	// 属性类型
	private String attrType;
	// auto_increment
	private String extra;

	public String getColumnName() {
		return columnName;
	}

	public void setColumnName(String columnName) {
		this.columnName = columnName;
	}

	public String getDataType() {
		return dataType;
	}

	public void setDataType(String dataType) {
		this.dataType = dataType;
	}

	public String getComments() {
		return comments;
	}

	public void setComments(String comments) {
		this.comments = comments;
	}

	public String getAttrname() {
		return attrname;
	}

	public void setAttrname(String attrname) {
		this.attrname = attrname;
	}

	public String getAttrName() {
		return attrName;
	}

	public void setAttrName(String attrName) {
		this.attrName = attrName;
	}

	public String getAttrType() {
		return attrType;
	}

	public void setAttrType(String attrType) {
		this.attrType = attrType;
	}

	public String getExtra() {
		return extra;
	}

	public void setExtra(String extra) {
		this.extra = extra;
	}
}


import java.util.List;

/**
 * @Description:表数据
 * @author vander
 * @Date 2017/5/11
 */
public class TableEntity {
	// 表的名称
	private String tableName;
	// 表的备注
	private String comments;
	// 表的主键
	private ColumnEntity pk;

	// 表的列名(不包含主键)
	private List<ColumnEntity> columns;

	// 类名(第一个字母大写)，如：sys_user => SysUser
	private String className;
	// 类名(第一个字母小写)，如：sys_user => sysUser
	private String classname;

	public String getTableName() {
		return tableName;
	}

	public void setTableName(String tableName) {
		this.tableName = tableName;
	}

	public String getComments() {
		return comments;
	}

	public void setComments(String comments) {
		this.comments = comments;
	}

	public ColumnEntity getPk() {
		return pk;
	}

	public void setPk(ColumnEntity pk) {
		this.pk = pk;
	}

	public List<ColumnEntity> getColumns() {
		return columns;
	}

	public void setColumns(List<ColumnEntity> columns) {
		this.columns = columns;
	}

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

	public String getClassname() {
		return classname;
	}

	public void setClassname(String classname) {
		this.classname = classname;
	}
}

工具类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

/**
 * 日期工具类
 *
 * @author vander
 */
public final class DateUtil {

	private static SimpleDateFormat dateTimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
	private static SimpleDateFormat timeFormat = new SimpleDateFormat("HH:mm:ss");

	private DateUtil() {
	}

	/**
	 * 获取当前时间 yyyy-MM-dd
	 * 
	 * @return
	 */
	public static String getCurrentDate() {
		return dateFormat.format(new Date());
	}

	/**
	 * 获取当前时间 HH:mm:ss
	 * 
	 * @return
	 */
	public static String getCurrentTime() {
		return timeFormat.format(new Date());
	}

	/**
	 * 获取当前时间 yyyy-MM-dd HH:mm:ss
	 * 
	 * @return
	 */
	public static String getCurrentDateTime() {
		return dateTimeFormat.format(new Date());
	}

	/**
	 * 获取当前日期时间根据格式
	 * 
	 * @param formateStr
	 *            yyyy年，MM月，dd日，HH时，mm分，ss秒
	 * @return
	 */
	public static String getDateTimeByFormat(String formateStr) {
		SimpleDateFormat sdf = new SimpleDateFormat(formateStr);
		return sdf.format(new Date());
	}

	/**
	 * 字符串转日期时间格式
	 *
	 * @param dateStr
	 *            输入参数格式：yyyy-MM-dd HH:mm:ss
	 * @return
	 */
	public static Date stringToDateTime(String dateStr) {
		Date date = null;
		try {
			date = dateTimeFormat.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	/**
	 * 字符串转日期格式
	 *
	 * @param dateStr
	 *            输入参数格式：yyyy-MM-dd
	 * @return
	 */
	public static Date stringToDate(String dateStr) {

		Date date = null;
		try {
			date = dateFormat.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	/**
	 * 获取指定时间段内时间集合
	 *
	 * @param startTime
	 *            输入参数格式：yyyy-MM-dd 起始
	 * @param endTime
	 *            输入参数格式：yyyy-MM-dd 结束
	 * @param viwer
	 *            1-日、2-月、3-年
	 * @return
	 */
	public List<String> getDateBetween(String startTime, String endTime, String viwer) throws Exception {
		List list = new ArrayList();

		if ("1".equals(viwer)) {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Date startDate = sdf.parse(startTime);
			Date endDate = sdf.parse(endTime);

			Calendar start_cal = Calendar.getInstance();
			start_cal.setTime(startDate);

			int dayPeriod = (int) ((endDate.getTime() - startDate.getTime()) / 86400000L);
			list.add(sdf.format(start_cal.getTime()));
			for (int i = 0; i < dayPeriod; i++) {
				start_cal.add(5, 1);
				list.add(sdf.format(start_cal.getTime()));
			}
		} else {
			if ("2".equals(viwer)) {
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
				Date startDate = sdf.parse(startTime);
				Date endDate = sdf.parse(endTime);

				Calendar start_cal = Calendar.getInstance();
				start_cal.setTime(startDate);

				Calendar end_cal = Calendar.getInstance();
				end_cal.setTime(endDate);

				list.add(sdf.format(start_cal.getTime()));

				while (!sdf.format(start_cal.getTime()).equals(sdf.format(end_cal.getTime()))) {
					start_cal.add(2, 1);
					list.add(sdf.format(start_cal.getTime()));
				}
			}
			if ("3".equals(viwer)) {
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
				Date startDate = sdf.parse(startTime);
				Date endDate = sdf.parse(endTime);

				Calendar start_cal = Calendar.getInstance();
				start_cal.setTime(startDate);

				Calendar end_cal = Calendar.getInstance();
				end_cal.setTime(endDate);

				list.add(sdf.format(start_cal.getTime()));

				while (!sdf.format(start_cal.getTime()).equals(sdf.format(end_cal.getTime()))) {
					start_cal.add(1, 1);
					list.add(sdf.format(start_cal.getTime()));
				}
			}
		}
		return list;
	}

	/**
	 * 处理请求参数
	 * 
	 * @param time
	 * @param viwer
	 * @return 1-日、2-月、3-年
	 */
	private String addOne(String time, String viwer) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Calendar cd = Calendar.getInstance();
			cd.setTime(sdf.parse(time));
			if ("1".equals(viwer)) {
				cd.add(Calendar.DATE, 1);
			}
			if ("2".equals(viwer)) {
				cd.add(Calendar.MONTH, 1);
			}
			if ("3".equals(viwer)) {
				cd.add(Calendar.YEAR, 1);
			}
			return sdf.format(cd.getTime());
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 字符串转时间格式
	 *
	 * @param dateStr
	 *            输入参数格式：HH:mm:ss
	 * @return
	 */
	public static Date stringToTime(String dateStr) {
		Date date = null;
		try {
			date = timeFormat.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	public static void main(String[] args) {
		Date date = DateUtil.stringToDateTime("2017-01-24 12:22:11");
		System.out.println(date);
	}
}


import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.WordUtils;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;

import com.plxc.generator.red.entity.ColumnEntity;
import com.plxc.generator.red.entity.TableEntity;

/**
 * @Description:代码生成器 工具类
 * @author vander
 * @Date 2017/5/11
 */
public class GenUtils {

	public static List<String> getTemplates() {
		List<String> templates = new ArrayList<String>();
		templates.add("template/Entity.java.vm");
		templates.add("template/Dao.java.vm");
		templates.add("template/Dao.xml.vm");
		templates.add("template/Service.java.vm");
		templates.add("template/ServiceImpl.java.vm");
		templates.add("template/Controller.java.vm");
//		templates.add("template/list.html.vm");
//		templates.add("template/list.js.vm");
//		templates.add("template/menu.sql.vm");
		return templates;
	}

	/**
	 * 生成代码
	 */
	public static void generatorCode(Map<String, Object> table, List<Map<String, Object>> columns, ZipOutputStream zip) {
		// 配置信息
		Configuration config = getConfig();

		// 表信息
		TableEntity tableEntity = new TableEntity();
		tableEntity.setTableName(table.get("tableName").toString());
		tableEntity.setComments(table.get("tableComment").toString());
		// 表名转换成Java类名
		String className = tableToJava(tableEntity.getTableName(), config.getString("tablePrefix"));
		tableEntity.setClassName(className);
		tableEntity.setClassname(StringUtils.uncapitalize(className));

		// 列信息
		List<ColumnEntity> columsList = new ArrayList<>();
		for (Map<String, Object> column : columns) {
			ColumnEntity columnEntity = new ColumnEntity();
			columnEntity.setColumnName(column.get("columnName").toString());
			String dataType = column.get("dataType").toString().toUpperCase();
			//jdbcType类型：
			switch (dataType) {
			case "INT":
				dataType = "INTEGER";
				break;
			case "TEXT":
				dataType = "VARCHAR";
				break;
			}
			columnEntity.setDataType(StringUtils.equalsIgnoreCase(dataType, "datetime")?"TIMESTAMP":dataType);
			columnEntity.setComments(column.get("columnComment").toString());
			columnEntity.setExtra(column.get("extra").toString());

			// 列名转换成Java属性名
			String attrName = columnToJava(columnEntity.getColumnName());
			columnEntity.setAttrName(attrName);
			columnEntity.setAttrname(StringUtils.uncapitalize(attrName));

			// 列的数据类型，转换成Java类型
			String attrType = config.getString(columnEntity.getDataType().toLowerCase(), "unknowType");
			columnEntity.setAttrType(attrType);

			// 是否主键
			if ("PRI".equalsIgnoreCase(column.get("columnKey").toString()) && tableEntity.getPk() == null) {
				tableEntity.setPk(columnEntity);
			}

			columsList.add(columnEntity);
		}
		tableEntity.setColumns(columsList);

		// 没主键，则第一个字段为主键
		if (tableEntity.getPk() == null) {
			tableEntity.setPk(tableEntity.getColumns().get(0));
		}

		// 设置velocity资源加载器
		Properties prop = new Properties();
		prop.put("file.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
		Velocity.init(prop);

		// 封装模板数据
		Map<String, Object> map = new HashMap<>();
		map.put("tableName", tableEntity.getTableName());
		map.put("comments", tableEntity.getComments());
		map.put("pk", tableEntity.getPk());
		map.put("className", tableEntity.getClassName());
		map.put("classname", tableEntity.getClassname());
		map.put("pathName", tableEntity.getClassname().toLowerCase());
		map.put("columns", tableEntity.getColumns());
		map.put("package", config.getString("package"));
		map.put("author", config.getString("author"));
		map.put("datetime", DateUtil.getCurrentDateTime());
		VelocityContext context = new VelocityContext(map);

		// 获取模板列表
		List<String> templates = getTemplates();
		for (String template : templates) {
			// 渲染模板
			StringWriter sw = new StringWriter();
			Template tpl = Velocity.getTemplate(template, "UTF-8");
			tpl.merge(context, sw);

			try {
				// 添加到zip
				zip.putNextEntry(new ZipEntry(getFileName(template, tableEntity.getClassName(), config.getString("package"))));
				IOUtils.write(sw.toString(), zip, "UTF-8");
				IOUtils.closeQuietly(sw);
				zip.closeEntry();
			} catch (IOException e) {
				throw new RuntimeException("渲染模板失败，表名：" + tableEntity.getTableName(), e);
			}
		}
	}

	/**
	 * 列名转换成Java属性名
	 */
	public static String columnToJava(String columnName) {
		return WordUtils.capitalizeFully(columnName, new char[] { '_' }).replace("_", "");
	}

	/**
	 * 表名转换成Java类名
	 */
	public static String tableToJava(String tableName, String tablePrefix) {
		if (StringUtils.isNotBlank(tablePrefix)) {
			tableName = tableName.replaceFirst(tablePrefix, "");
		}
		return columnToJava(tableName);
	}

	/**
	 * 获取配置信息
	 */
	public static Configuration getConfig() {
		try {
			return new PropertiesConfiguration("generator.properties");
		} catch (ConfigurationException e) {
			throw new RuntimeException("获取配置文件失败，", e);
		}
	}

	/**
	 * 获取文件名
	 */
	public static String getFileName(String template, String className, String packageName) {
		String packagePath = "main" + File.separator + "java" + File.separator;
		if (StringUtils.isNotBlank(packageName)) {
			packagePath += packageName.replace(".", File.separator) + File.separator;
		}

		if (template.contains("Entity.java.vm")) {
			return packagePath + "po" + File.separator + className + ".java";
		}

		if (template.contains("Dao.java.vm")) {
			return packagePath + "dao" + File.separator + className + "Dao.java";
		}

		if (template.contains("Dao.xml.vm")) {
			return packagePath + "maper" + File.separator + className + "-mapper.xml";
		}

		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("Controller.java.vm")) {
			return packagePath + "controller" + File.separator + className + "Controller.java";
		}

//		if (template.contains("list.html.vm")) {
//			return "main" + File.separator + "webapp" + File.separator + "WEB-INF" + File.separator + "page" + File.separator + "generator" + File.separator + className.toLowerCase() + ".html";
//		}
//
//		if (template.contains("list.js.vm")) {
//			return "main" + File.separator + "webapp" + File.separator + "js" + File.separator + "generator" + File.separator + className.toLowerCase() + ".js";
//		}
//
//		if (template.contains("menu.sql.vm")) {
//			return className.toLowerCase() + "_menu.sql";
//		}

		return null;
	}
}


import java.sql.Connection;
import java.sql.SQLException;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

/**
 * 
 * @author Vander
 * @author 2018年4月13日
 */
public class JDBCUtils {
	private static final ComboPooledDataSource DATA_SOURCE = new ComboPooledDataSource("demo");
	private static final ThreadLocal<Connection> TL = new ThreadLocal<Connection>();

	// 获取数据源
	public static DataSource getDataSource() {
		return DATA_SOURCE;
	}

	// 获取连接
	public static Connection getConnection() {
		Connection conn = null;
		try {
			conn = TL.get();
			if (conn == null) {
				conn = DATA_SOURCE.getConnection();
				TL.set(conn);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}

	// 开启事务
	public static void startTransaction() {
		try {
			// 得到当前线程上绑定连接开启事务
			Connection conn = getConnection();
			conn.setAutoCommit(false);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	// 提交事务
	public static void commitTransaction() {
		try {
			Connection conn = getConnection();
			if (conn != null) {
				conn.commit();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	// 事务回滚
	public static void rollbackTransaction() {
		try {
			Connection conn = getConnection();
			if (conn != null) {
				conn.rollback();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	// 关闭连接
	public static void closeConnection() {
		try {
			Connection conn = getConnection();
			if (conn != null) {
				conn.close();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			// 解除当前线程上绑定的链接
			TL.remove();
		}
	}
}

主方法

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipOutputStream;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;

import com.plxc.generator.red.utils.GenUtils;
import com.plxc.generator.red.utils.JDBCUtils;

/**
 * @author Vander
 * @author 2018年4月13日
 */
public class Main {

	public static void main(String[] args) throws Exception {
		String[] tableNames = null;
		String string = GenUtils.getConfig().getString("tables");
		System.out.println(string);
		if (StringUtils.isBlank(string)) {
			 tableNames = getTables();
		}
		tableNames = GenUtils.getConfig().getString("tables").split(";");
		ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
		ZipOutputStream zip = new ZipOutputStream(outputStream);
		for (String tableName : tableNames) {
			// 查询表信息
			Map<String, Object> table = queryTable(tableName);
			// 查询列信息
			List<Map<String, Object>> columns = queryColumns(tableName);
			GenUtils.generatorCode(table, columns, zip);
		}
		IOUtils.closeQuietly(zip);
		byte[] bytes = outputStream.toByteArray();
		// 确定写出文件的位置
		File file = new File("D:\\code.zip");
		// 建立输出字节流
		FileOutputStream fos = new FileOutputStream(file);
		// 用FileOutputStream 的write方法写入字节数组
		fos.write(bytes);
		System.out.println("写入成功");
		// 为了节省IO流的开销，需要关闭
		fos.close();

	}

	/**
	 * 
	 * @param tableName
	 * @return 
	 * @throws Exception
	 */
	// 查询表信息
	public static Map<String, Object> queryTable(String tableName) throws Exception {
		QueryRunner runner = new QueryRunner(JDBCUtils.getDataSource());
		String sql = "select table_name tableName, engine, table_comment tableComment, create_time createTime from information_schema.tables where table_schema = (select database()) and table_name = ?";
		Map<String, Object> map = runner.query(sql, new MapHandler(), tableName);
		return map;
	}

	/**
	 * 
	 * @param tableName
	 * @return
	 * @throws Exception
	 */
	// 查询列信息
	public static List<Map<String, Object>> queryColumns(String tableName) throws Exception {
		QueryRunner runner = new QueryRunner(JDBCUtils.getDataSource());
		String sql = "select column_name columnName, data_type dataType, column_comment columnComment, column_key columnKey, extra from information_schema.columns where table_name = ? and table_schema = (select database()) order by ordinal_position";
		List<Map<String, Object>> map = runner.query(sql, new MapListHandler(), tableName);
		return map;
	}
	
	/**
	 * 获取库中所有表
	 * @return
	 * @throws Exception
	 */
	public static String[] getTables() throws Exception {
		QueryRunner runner = new QueryRunner(JDBCUtils.getDataSource());
		String sql = "show tables";
		List<Object[]> rs = runner.query(sql, new ArrayListHandler());
		String[] result = new String[rs.size()];
		for (int i = 0;i<rs.size();i++) {
			result[i] = rs.get(i)[0].toString();
		}
		return result;
	}
	
}