1.主程序中添加代码，执行sql脚本
 
 Spring 中提供了一个 jdbc 脚本执行器，使用这个工具可以非常方便的运行一个 sql 脚本文件，下面是这个方法：

 
ScriptUtils.executeSqlScript()
 只需要传入它需要的参数即可。
 
下面代码运行 sql 目录中的四个脚本程序，每次运行都会删除四个数据库再重新创建，并初始化数据。
 
package cn.tedu.dbinit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.jdbc.datasource.init.ScriptUtils;

import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import java.sql.SQLException;

@SpringBootApplication
public class DbInitApplication {

	@Autowired
	private DataSource dataSource;

	public static void main(String[] args) {
		SpringApplication.run(DbInitApplication.class, args);
	}

	@PostConstruct
	public void init() throws SQLException {
		exec(dataSource, "sql/account.sql");
		exec(dataSource, "sql/storage.sql");
		exec(dataSource, "sql/order.sql");
		exec(dataSource, "sql/seata-server.sql");
	}

	private void exec(DataSource accountDatasource, String script) throws SQLException {
		ClassPathResource rc = new ClassPathResource(script, DbInitApplication.class.getClassLoader());
		EncodedResource er = new EncodedResource(rc, "utf-8");
		ScriptUtils.executeSqlScript(accountDatasource.getConnection(), er);
	}
}

本文转载自：
http://www.cnblogs.com/linlf03/archive/2012/12/16/2820677.html  作者：linlf03 转载请注明该声明。


Java 使用execute方法执行Sql语句。
 
mysql.ini是一个配置文件。配置内容可以看上一篇。
 
 
 
class ExecuteSql {
	private String driver;
	private String url;
	private String user;
	private String pass;
	Connection conn;
	Statement stmt;
	ResultSet rs;
	public void initParam(String paramFile) throws Exception {
		Properties props = new Properties();
		props.load(new FileInputStream(paramFile));
		driver = props.getProperty("driver");
		url = props.getProperty("url");
		user = props.getProperty("user");
		pass = props.getProperty("pass");		
	}
	
	public void executeSql(String sql) throws Exception{
		try {
			Class.forName(driver);
			conn = DriverManager.getConnection(url,user,pass);
			stmt = conn.createStatement();
			boolean hasResultSet = stmt.execute(sql);
			if (hasResultSet) {
				rs = stmt.getResultSet();
				java.sql.ResultSetMetaData rsmd = rs.getMetaData();
				int columnCount = rsmd.getColumnCount();
				
				while (rs.next()) {
					for (int i = 0; i < columnCount; i++) {
						System.out.print(rs.getString(i+1) + "\t");
					}
					System.out.println();
					
				}
			}
			else {
				System.out.println("改SQL语句影响的记录有" + stmt.getUpdateCount() + "条");
			}
		} 
		finally
		{
			if (rs != null) {
				rs.close();
			}
			if (stmt != null) {
				stmt.close();
			}
			if (conn != null) {
				conn.close();
			}
		}
	}
	
	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		
		ExecuteDDL ed = new ExecuteDDL();
		ed.initParam("src/mysql.ini");
	
		ed.executeSql("drop table if exists school"); //(insertSql);	
		ed.executeSql("create table school(id int, name varchar(50), addr varchar(50))");		
		ed.executeSql("insert into school values(1, 'No1', 'BeiJing')");	
		ed.executeSql("select * from school");	
	}
	

}
 
 
　　执行结果为：
 

最近要实现一个简易的数据库系统，除了要考虑如何高效的存储和访问数据，建立表关系外，对基本的sql查询语句要做一个解析，这样我们才能知道用户的查询要求；因为时间关系，参考了已有的一篇文章，并对其实现中出的小问题给予更正，在这里跟大家共享一下。原文请查阅http://www.cnblogs.com/pelephone/articles/sql-parse-single-word.html
 
第一步：先对sql语句进行预处理；
 
对于用户，我们应该接受各种形式的查询语句书写，单行或者多行，语句中单个空格或者多个空格的间隔等等。但是我们要解析sql语句，就首先要让对它们做标准化，这样才能进行我们下一步处理。系统中的处理要求：
 
1）消除SQL语句前后的空白，将其中的连续空白字符（包括空格，TAB和回车换行）替换成单个空格；
 
2）将sql语句全变成小写形式（或大写形式）；
 
3）在SQL语句的尾后加上结束符号“ENDOFSQL”（原因后面解释）
 
例如：用户输入：“select c1,c2,c3 from　　t1,t2,　t3 where condi1=5 and condi6=6 or condi7=7 order　
 
by g1,g2”
 
通过预处理应该为：“select c1,c2,c3 from t1,t2,t3 where condi1=5 and condi6=6 or condi7=7 order by g1,g2”
 
第二步：将查询语句切分为语句块；
 
以查询语句为例（本文中主要是以查询语句作为例子讲解，其它删除，插入等语句原理于此类似，因为查询语句相对复杂，所以用来i讲解），正如上面我们标准化后的语句一样，我们要进行下一步的，对表中数据的处理，首先要知道是对那些表处理，要满足那些条件，输出那些属性，以什么顺序输出等。所以查询语句就可以分割为以下几个块：
 
1）select c1,c2,c3 from：属性输出块；块头（start）select，块尾(end)from，这个块我们关心的信息(body)：c1,c2,c3；以下块类似分析
 
2）from....where; 涉及数据表块。
 
3）where.....order by; 查询条件块。
 
4）order by.....ENDOFSQL; 属性输出顺序。这里也就看出了我们为什么要在查询语句末尾加上结束符，是为了最后一个块的限定需要。
 
知道了如何分块，接下来要做的就是在我们已经标准化的sql语句上进行块的切割，这里我们用到了正则表达式，以第二个块from....where的查询为例，我们做个分析
 
"(from)(.+)( where | on | having | group by | order by | ENDOFSQL)“
 
以上就是第二个块的正则匹配式（其它块的匹配式下面也会给出），可以看出，在一个sql查询语句中，from块中跟from搭配出现的不只是where，还可以是on,having,group by等，那么通过这个正则式我们可以得到如下的块：
 
      from .... where
 
　　from .... on
 
　　from .... having
 
　　from .... group by
 
　　from .... order by
 
　　from .... ENDOFSQL
 
这里我们要注意一点，就是在通过正则式对sql语句进行匹配时，我们不能对整个sql语句进行一次匹配操作，因为正则匹配是贪心匹配，它总是尽可能的向后查找，匹配到最大的语句段。就拿上述语句为例，如果通过对整个sql语句进行一次匹配，得到的就不是from....where这个语句段而是from .... where .... order by。显然这不是我们想要的。所以我们只能牺牲效率，通过对整个sql语句进行逐次递增的查询方式来查找相应的语句块。给出一个查询过程，加强理解，以上述sql语句为例，对第一个语句块的查找过程是
 
s
 se
 sel
 sele
 selec
 select
 select 
 select c
 select c1
 select c1,
 select c1,c
 select c1,c2
 select c1,c2,
 select c1,c2,c
 select c1,c2,c3
 select c1,c2,c3 
 select c1,c2,c3 f
 select c1,c2,c3 fr
 select c1,c2,c3 fro
 select c1,c2,c3 from
 
这样就找到第一个块，以此类推，找第二个块时候又从头逐次递增查找。
 
第三步：找到了各个块，我们还要把我们最关心的信息提取出来，就是夹在语句块头和尾之间的body部分，这个就好实现了，一般的sql语句中都会用逗号来做分割，我们提取出各个块的body信息。
 
步骤介绍完了，下面就上代码，享乐吧...少年！
package com.sitinspring.common.sqlparser.single;

import java.util.List;

/** *//**
* 单句Sql解析器制造工厂
* @author 赵朝峰
*
* @since 2013-6-10
* @version 1.00
*/
public class SqlParserUtil{
    /** *//**
    　* 方法的主要入口
    　* @param sql:要解析的sql语句
    　* @return 返回解析结果
    　*/
    public String getParsedSql(String sql){
        sql=sql.trim();
        sql=sql.toLowerCase();
        sql=sql.replaceAll("\\s{1,}", " ");
        sql=""+sql+" ENDOFSQL";
        //System.out.println(sql);
        return SingleSqlParserFactory.generateParser(sql).getParsedSql();
    }
    
    /** *//**
    　* SQL语句解析的接口
    　* @param sql:要解析的sql语句
    　* @return 返回解析结果
    　*/
    public List<SqlSegment> getParsedSqlList(String sql)
    {
        sql=sql.trim();
        sql=sql.toLowerCase();
        sql=sql.replaceAll("\\s{1,}", " ");
        sql=""+sql+" ENDOFSQL";
        //System.out.println(sql);
        return SingleSqlParserFactory.generateParser(sql).RetrunSqlSegments();
    }
    }
package com.sitinspring.common.sqlparser.single;

//import com.sitinspring.common.sqlparser.single.NoSqlParserException;
import java.util.ArrayList;
import java.util.List;
import com.sitinspring.common.sqlparser.single.SqlSegment;
/** *//**
* 单句Sql解析器，单句即非嵌套的意思
* @author 赵朝峰（）
*
* @since 2013-6-10
* @version 1.00
*/
public abstract class BaseSingleSqlParser{
/** *//**
　* 原始Sql语句
　*/
protected String originalSql;
/** *//**
　* Sql语句片段
　*/
protected List<SqlSegment> segments;
/** *//**
　* 构造函数，传入原始Sql语句，进行劈分。
　* @param originalSql
　*/
public BaseSingleSqlParser(String originalSql){
    this.originalSql=originalSql;
    segments=new ArrayList<SqlSegment>();
    initializeSegments();
    splitSql2Segment();
}
/** *//**
　* 初始化segments，强制子类实现
　*
　*/
protected abstract void initializeSegments();
/** *//**
　* 将originalSql劈分成一个个片段
　*
　*/
protected void splitSql2Segment() {
    for(SqlSegment sqlSegment:segments)
    {
        sqlSegment.parse(originalSql);
    }
}
/** *//**
　* 得到解析完毕的Sql语句
　* @return
　*/
public String getParsedSql() {
    
    //测试输出各个片段的信息
    /*
    for(SqlSegment sqlSegment:segments)
    {
        String start=sqlSegment.getStart();
        String end=sqlSegment.getEnd();
        System.out.println(start);
        System.out.println(end);
    }
    */
    
    StringBuffer sb=new StringBuffer();
    for(SqlSegment sqlSegment:segments)
    {
        sb.append(sqlSegment.getParsedSqlSegment());
    }
    String retval=sb.toString().replaceAll("@+", "\n");
    return retval;
}
/** *//**
* 得到解析的Sql片段
* @return
*/
public List<SqlSegment> RetrunSqlSegments()
{
    int SegmentLength=this.segments.size();
    if(SegmentLength!=0)
    {
      List<SqlSegment> result=this.segments;
      return result;
    }
    else
    {
        //throw new Exception();
        return null;
    }
}
}
package com.sitinspring.common.sqlparser.single;

import com.sitinspring.common.sqlparser.single.SqlSegment;
/** *//**
*
* 单句删除语句解析器
* @author 赵朝峰
*
* @since 2013-6-10
* @version 1.00
*/
public class DeleteSqlParser extends BaseSingleSqlParser{
public DeleteSqlParser(String originalSql) {
    super(originalSql);
}
@Override
protected void initializeSegments() {
    segments.add(new SqlSegment("(delete from)(.+)( where | ENDOFSQL)","[,]"));
    segments.add(new SqlSegment("(where)(.+)( ENDOFSQL)","(and|or)"));
}
}
package com.sitinspring.common.sqlparser.single;

import com.sitinspring.common.sqlparser.single.SqlSegment;
/** *//**
*
* 单句查询插入语句解析器
* @author 赵朝峰
*
* @since 2013-6-10
* @version 1.00
*/
public class InsertSelectSqlParser extends BaseSingleSqlParser{
public InsertSelectSqlParser(String originalSql) {
    super(originalSql);
}
@Override
protected void initializeSegments() {
    segments.add(new SqlSegment("(insert into)(.+)( select )","[,]"));
    segments.add(new SqlSegment("(select)(.+)(from)","[,]"));
    segments.add(new SqlSegment("(from)(.+)( where | on | having | groups+by | orders+by | ENDOFSQL)","(,|s+lefts+joins+|s+rights+joins+|s+inners+joins+)"));
    segments.add(new SqlSegment("(where|on|having)(.+)( groups+by | orders+by | ENDOFSQL)","(and|or)"));
    segments.add(new SqlSegment("(groups+by)(.+)( orders+by| ENDOFSQL)","[,]"));
    segments.add(new SqlSegment("(orders+by)(.+)( ENDOFSQL)","[,]"));
}
}
package com.sitinspring.common.sqlparser.single;

import com.sitinspring.common.sqlparser.single.SqlSegment;
/** *//**
*
* 单句插入语句解析器
* @author 赵朝峰
*
* @since 2013-6-10
* @version 1.00
*/
public class InsertSqlParser extends BaseSingleSqlParser{
public InsertSqlParser(String originalSql) {
    super(originalSql);
}
@Override
protected void initializeSegments() {
    segments.add(new SqlSegment("(insert into)(.+)([(])","[,]"));
    segments.add(new SqlSegment("([(])(.+)( [)] values )","[,]"));
    segments.add(new SqlSegment("([)] values [(])(.+)( [)])","[,]"));
}
@Override
public String getParsedSql() {
    String retval=super.getParsedSql();
    retval=retval+")";
    return retval;
}
}

复制代码
复制代码

package com.sitinspring.common.sqlparser.single;

public class NoSqlParserException extends Exception{
    private static final long serialVersionUID = 1L;
    NoSqlParserException()
    {
        
    }
    NoSqlParserException(String sql)
    {
        //调用父类方法
        super(sql);
    }
}

 
package com.sitinspring.common.sqlparser.single;

import com.sitinspring.common.sqlparser.single.SqlSegment;
/** *//**
*
* 单句查询语句解析器
* @author 赵朝峰
*
* @since 2013-6-10
* @version 1.00
*/
public class SelectSqlParser extends BaseSingleSqlParser{
public SelectSqlParser(String originalSql) {
    super(originalSql);
}
@Override
protected void initializeSegments() {
    segments.add(new SqlSegment("(select)(.+)(from)","[,]"));
    segments.add(new SqlSegment("(from)(.+)( where | on | having | group by | order by | ENDOFSQL)","(,| left join | right join | inner join )"));
    segments.add(new SqlSegment("(where|on|having)(.+)( group by | order by | ENDOFSQL)","(and|or)"));
    segments.add(new SqlSegment("(group by)(.+)( order by| ENDOFSQL)","[,]"));
    segments.add(new SqlSegment("(order by)(.+)( ENDOFSQL)","[,]"));
}
}
package com.sitinspring.common.sqlparser.single;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
//import com.sitinspring.common.sqlparser.single.NoSqlParserException;
/** *//**
* 单句Sql解析器制造工厂
* @author 赵朝峰
*
* @since 2013-6-10
* @version 1.00
*/
public class SingleSqlParserFactory{
public static BaseSingleSqlParser generateParser(String sql)
{
    if(contains(sql,"(insert into)(.+)(select)(.+)(from)(.+)"))
    {
        return new InsertSelectSqlParser(sql);
    }
    else if(contains(sql,"(select)(.+)(from)(.+)"))
    {
        return new SelectSqlParser(sql);
    }
    else if(contains(sql,"(delete from)(.+)"))
    {
        return new DeleteSqlParser(sql);
    }
    else if(contains(sql,"(update)(.+)(set)(.+)"))
    {
        return new UpdateSqlParser(sql);
    }
    else if(contains(sql,"(insert into)(.+)(values)(.+)"))
    {
        return new InsertSqlParser(sql);
    }
    //sql=sql.replaceAll("ENDSQL", "");
    else
        return new InsertSqlParser(sql);
       //throw new NoSqlParserException(sql.replaceAll("ENDOFSQL", ""));//对异常的抛出
}
/** *//**
　* 看word是否在lineText中存在，支持正则表达式
　* @param sql:要解析的sql语句
　* @param regExp:正则表达式
　* @return
　*/
private static boolean contains(String sql,String regExp){
    Pattern pattern=Pattern.compile(regExp,Pattern.CASE_INSENSITIVE);
    Matcher matcher=pattern.matcher(sql);
    return matcher.find();
}
}
package com.sitinspring.common.sqlparser.single;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/** *//**
* Sql语句片段
*
* @author 赵朝峰
*
* @since 2013-6-10
* @version 1.00
*/
public class SqlSegment{
private static final String Crlf = "@";
private static final String FourSpace = "　　";
/** *//**
　* Sql语句片段开头部分
　*/
private String start;
/** *//**
　* Sql语句片段中间部分
　*/
private String body;
/** *//**
　* Sql语句片段结束部分
　*/
private String end;
/** *//**
　* 用于分割中间部分的正则表达式
　*/
private String bodySplitPattern;
/** *//**
　* 表示片段的正则表达式
　*/
private String segmentRegExp;
/** *//**
　* 分割后的Body小片段
　*/
private List<String> bodyPieces;
/** *//**
　* 构造函数
　* @param segmentRegExp 表示这个Sql片段的正则表达式
　* @param bodySplitPattern 用于分割body的正则表达式
　*/
public SqlSegment(String segmentRegExp,String bodySplitPattern){
    start="";
    body="";
    end="";
    this.segmentRegExp=segmentRegExp;
    this.bodySplitPattern=bodySplitPattern;
    this.bodyPieces=new ArrayList<String>();
    
}
/** *//**
　* 从sql中查找符合segmentRegExp的部分，并赋值到start,body,end等三个属性中
　* @param sql
　*/
public void parse(String sql){
    Pattern pattern=Pattern.compile(segmentRegExp,Pattern.CASE_INSENSITIVE);
    for(int i=0;i<=sql.length();i++)
    {
     String shortSql=sql.substring(0, i);
     //测试输出的子句是否正确
     System.out.println(shortSql);
     Matcher matcher=pattern.matcher(shortSql);
     while(matcher.find())
     {
         start=matcher.group(1);
         body=matcher.group(2);
         //测试body部分
         //System.out.println(body);
         end=matcher.group(3);
         //测试相应的end部分
         //System.out.println(end);
         parseBody();
         return;
     }
    }
}
/** *//**
　* 解析body部分
　*
　*/
private void parseBody(){
    
    List<String> ls=new ArrayList<String>();
    Pattern p = Pattern.compile(bodySplitPattern,Pattern.CASE_INSENSITIVE);
    // 先清除掉前后空格
    body=body.trim();
    Matcher m = p.matcher(body);
    StringBuffer sb = new StringBuffer();
    boolean result = m.find();
    while(result)
    {
        m.appendReplacement(sb, m.group(0) + Crlf);
        result = m.find();
    }
    m.appendTail(sb);
    // 再按空格断行
    String[] arr=sb.toString().split(" ");
    int arrLength=arr.length;
    for(int i=0;i<arrLength;i++)
    {
        String temp=FourSpace+arr[i];
        if(i!=arrLength-1)
        {
            //temp=temp+Crlf;
        }
        ls.add(temp);
    }
    bodyPieces=ls;
}
/** *//**
　* 取得解析好的Sql片段
　* @return
　*/
public String getParsedSqlSegment(){
    StringBuffer sb=new StringBuffer();
    sb.append(start+Crlf);
    for(String piece:bodyPieces)
    {
        sb.append(piece+Crlf);
    }
    return sb.toString();
}

public String getBody()
{
    return body;
}

public void setBody(String body)
{
    this.body=body;
}

public String getEnd()
{
    return end;
}

public void setEnd(String end)
{
    this.end=end;
}

public String getStart()
{
    return start;
}


public void setStart(String start) 
{
    this.start=start;
}


}
 
package com.sitinspring.common.sqlparser.single;

import com.sitinspring.common.sqlparser.single.SqlSegment;
/** *//**
*
* 单句更新语句解析器
* @author 赵朝峰
*
* @since 2013-6-10
* @version 1.00
*/
public class UpdateSqlParser extends BaseSingleSqlParser{
public UpdateSqlParser(String originalSql) {
    super(originalSql);
}
@Override
protected void initializeSegments() {
    segments.add(new SqlSegment("(update)(.+)(set)","[,]"));
    segments.add(new SqlSegment("(set)(.+)( where | ENDOFSQL)","[,]"));
    segments.add(new SqlSegment("(where)(.+)( ENDOFSQL)","(and|or)"));
}
}
 执行结果：自己写了个测试的类

 
import java.util.List;

import com.sitinspring.common.sqlparser.single.*;
public class Test {
    /** *//**
    * 单句Sql解析器制造工厂
    * @author 赵朝峰
    *
    * @since 2013-6-10
    * @version 1.00
    */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
       //String test="select  a from  b " +
           //    "\n"+"where      a=b";
       //test=test.replaceAll("\\s{1,}", " ");
       //System.out.println(test);
       //程序的入口
        String testSql="select c1,c2,c3     from    t1,t2 where condi3=3 "+"\n"+"    or condi4=5 order by o1,o2";
        SqlParserUtil test=new SqlParserUtil();
        String result=test.getParsedSql(testSql);
        System.out.println(result);
       //List<SqlSegment> result=test.getParsedSqlList(testSql);//保存解析结果
    }

}
结果为

select
     c1,
     c2,
     c3
from
      t1,
      t2
where
　　condi3=3
　　or
　　condi4=5
order by
　　o1,
     o2

 

 

 

 

 

 

 

 

 

 
 
有的时候把数据库删了，如果照着实体类重新创建数据库的话比较麻烦，可以使用这个工具，把代码复制到项目里面设置一下即可把Java代码中的实体类转换为SQL语句输出为一个文件，打开执行命令即可。
 
 
下载：https://download.csdn.net/download/weixin_44893902/20367422
 
 
代码如下：
 
package Main;

import javax.xml.bind.annotation.XmlElement;
import java.io.*;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;

public class GenerateSqlFromEntityUtil {

	public static void main(String[] a) {
		// 实体类的位置
		Class klass = cn.ac.azure.model.User.class;
		// 生成的sql语句的位置
		String outputPath = "D:/outSql/User.txt";
		generateTableSql(klass, outputPath, null);
		System.out.println("生成结束");
	}

	public static void writeFile(String content, String outputPath) {
		File file = new File(outputPath);
		System.out.println("文件路径: " + file.getAbsolutePath());
		// 输出文件的路径
		if (!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}
		FileOutputStream fos = null;
		OutputStreamWriter osw = null;
		BufferedWriter out = null;

		try {
			// 如果文件存在，就删除
			if (file.exists()) {
				file.delete();
			}
			file.createNewFile();
			fos = new FileOutputStream(file, true);
			osw = new OutputStreamWriter(fos);
			out = new BufferedWriter(osw);
			out.write(content);
			// 清空缓冲流，把缓冲流里的文本数据写入到目标文件里
			out.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}

			try {
				osw.close();
			} catch (IOException e) {
				e.printStackTrace();
			}

			try {
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	public static void generateTableSql(Class obj, String outputPath, String tableName) {
		// tableName 如果是 null，就用类名做表名
		if (tableName == null || tableName.equals("")) {
			tableName = obj.getName();
			tableName = tableName.substring(tableName.lastIndexOf(".") + 1);
		}
		// 表名用大写字母
		tableName = tableName.toUpperCase();

		Field[] fields = obj.getDeclaredFields();
		Object param;
		String column;

		StringBuilder sb = new StringBuilder();

		sb.append("drop table if exists ").append(tableName).append(";\r\n");

		sb.append("\r\n");

		sb.append("create table ").append(tableName).append("(\r\n");

		System.out.println(tableName);

		boolean firstId = true;

		for (int i = 0; i < fields.length; i++) {
			Field f = fields[i];

			column = f.getName();

			System.out.println(column + ", " + f.getType().getSimpleName());

			param = f.getType();
			sb.append(column); // 一般第一个是主键

			if (param instanceof Integer) {
				sb.append(" INTEGER ");
			} else {
				// 注意：根据需要，自行修改 varchar 的长度。这里设定为长度等于 50
				int length = 50;
				sb.append(" VARCHAR(" + length + ")");
			}

			if (firstId == true) {
				sb.append(" PRIMARY KEY ");
				firstId = false;
			}

			// 获取字段中包含 fieldMeta 的注解

			// 获取属性的所有注释
			Annotation[] allAnnotations = f.getAnnotations();

			XmlElement xmlElement = null;
			Class annotationType = null;

			for (Annotation an : allAnnotations) {
				sb.append(" COMMIT '");
				xmlElement = (XmlElement) an;
				annotationType = an.annotationType();
				param = ((XmlElement) an).name();
				System.out.println("属性 " + f.getName() + " ----- 的注释类型有: " + param);
				sb.append(param).append("'");
			}

			if (i != fields.length - 1) { // 最后一个属性后面不加逗号
				sb.append(", ");
			}

			sb.append("\n");
		}

		String sql = sb.toString();

		sql = sb.substring(0, sql.length() - 1) + "\n) " + "ENGINE = INNODB DEFAULT CHARSET = utf8;";

		writeFile(sql, outputPath);
	}
}