精华内容
下载资源
问答
  • java定时执行sql语句

    2018-03-09 16:13:00
    通过配置数据库连接信息和要执行sql语句,可实现定时执行多个sql语句。 所要执行的语句只能是写死的,可支持sqlserver mysql oracle。 配置说明: config/sys.properties 中指定数据库类型及连接信息,执行间隔...
  • 1.主程序中添加代码,执行sql...下面代码运行 sql 目录中的四个脚本程序,每次运行都会删除四个数据库再重新创建,并初始化数据。 package cn.tedu.dbinit; import org.springframework.beans.factory.annotation.Auto

    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);
    	}
    }
    
    展开全文
  • JAVA的SQL帮助类,帮助使用jdbc快速使用SQL语句更新,删除,查询数据,只需要专注于SQL语句执行,而不需要写数据库的连接与释放
  • Java 使用execute方法执行Sql语句

    千次阅读 2020-01-05 09:10:37
    本文转载自:...Java 使用execute方法执行Sql语句。 mysql.ini是一个配置文件。配置内容可以看上一篇。 class ExecuteSql { private String driver; private...
    本文转载自:
    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");	
    	}
    	
    
    }
    

      执行结果为:

    展开全文
  • Java 实现对Sql语句解析

    千次阅读 2017-07-21 14:52:07
    最近要实现一个简易的数据库系统,除了要考虑如何高效的存储和访问数据,建立表关系外,对基本的sql查询语句要做一个解析,这样我们才能知道用户的查询要求;因为时间关系,参考了已有的一篇文章,并对其实现中出的...

    最近要实现一个简易的数据库系统,除了要考虑如何高效的存储和访问数据,建立表关系外,对基本的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语句Java实体类转数据库)

    万次阅读 多人点赞 2021-07-19 17:43:04
    有的时候把数据库删了,如果照着实体类重新创建数据库的话比较麻烦,可以使用这个工具,把代码复制到项目里面设置一下即可把Java代码中的实体类转换为SQL语句输出为一个文件,打开执行命令即可。 代码如下: ...

    有的时候把数据库删了,如果照着实体类重新创建数据库的话比较麻烦,可以使用这个工具,把代码复制到项目里面设置一下即可把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);
    	}
    }
    
    展开全文
  • Sorm4j将Java对象设置为SQL语句的参数并执行SQL语句,然后将结果映射到Java对象。它会打开与数据库的连接,并在执行后自动将其关闭。 这是lambda表达式的示例: // Creates an entry point as javax.sql....
  • Java一次执行多条SQL语句

    万次阅读 2017-10-11 19:27:35
    本实例将演示如何一次执行多条SQL语句,这些SQL语句可以是插入语句、更新语句和删除语句。本实例以myuser数据库中的staff表为例。 | |目录 1技术要点 2代码实现 3程序解读 1技术要点 一次...
  • JDBCTM中Statement接口提供的...Statement 接口提供了三种执行 SQL 语句的方法:executeQuery、executeUpdate 和 execute。使用哪一个方法由 SQL 语句所产生的内容决定。 方法executeQuery 用于产生单个结果集...
  • 现在有一个需求,需要使用java代码来调用kettle来执行根据sql执行数据库的删除功能,请问具体代码该怎么实现??
  • java执行sql语句并获取指定返回值

    万次阅读 2012-06-06 12:22:57
    //得到预编译语句更新记录或删除操作的结果 int id = cst.getInt(1); //得到返回值 System.out.println("成功执行了:" + count + "条数据,其ID值:" + id); } catch (SQLException e1) { con....
  • Java执行sql语句并获取指定返回值

    千次阅读 2017-07-10 14:11:00
     //得到预编译语句更新记录或删除操作的结果  int id = cst.getInt(1); //得到返回值    System.out.println("成功执行了:" + count + "条数据,其ID值:" + id); } catch (SQLException e1) {  con....
  • java SQL语句简单实例

    2018-06-13 10:41:31
    id name kinds legs behavior 1 米老鼠 鼠类 4 夜间活动 2 蜈蚣 多足纲 40 用毒液杀死食物 3 加菲猫 猫类 4 好吃懒做 4 唐老鸭 家禽 2 叫个不停 5 肥猪 哺乳动物 4 吃和睡 (1) 使用INSERT语句将上述记录插入到...
  • drop sql语句 介绍 (Introduction) This guide covers the SQL statement for dropping ... 本指南介绍了用于删除(删除)一个或多个视图对象SQL语句。 A View is an object that presents data from one or mor...
  • Java SQL语句优化经验

    千次阅读 2018-05-25 13:36:22
    Java SQL语句优化经验总结(1)选择最有效率的表名顺序(只在基于规则的seo/' target='_blank'&gt;优化器中有效):ORACLE 的解析器按照从右到左的顺序处理FROM子句中的表名,FROM子句中写在最后的表(基础表 ...
  • import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement; import org.junit.Test; public class JDBCTest01 { public static void main(String[]...
  • StringBuffer类和String类一样,也用来代表字符串。...在实际使用时,如果需要经常对一个字符串进行修改,例如插入、删除等操作,使用StringBuffer更加适合。 对StringBuffer对象的每次修改都会改变对象自身,这
  • Statement的execute()语句可以执行任何SQL语句,但是它比较麻烦,故通常应该使用executeQuery()或者executeUpdate()方法。 使用exrcute()方法执行只是返回boolean值,它表示执行SQL语句是否返回了...
  • 1.java中用sql语句操作数据库有三种方式:到数据库协议连接数据库,到本地API方式连接数据库,JDBC-ODBC方式连接数据库,这三种不同方式都有不同的URL字符串,驱动字符串前两者相同,是"oracle.jdbc.driver.Oracle...
  • beetlSql删除语句

    千次阅读 2018-03-21 10:27:42
    在公司里遇到一种情况,需要删除...实际上在数据库中也能查到,一直不知道怎么解决,想要自己写sql语句实现删除,但是dao和sqlManager提供的delete方法里没有支持sqlId的,后来发现beetlSql的官方文档里,更新和删除...
  • 本文主要介绍使用Statement的execute()方法来执行任意的SQL语句,并列出你在运行该程序中可能会遇到的一系列问题,我只能将我在运行中遇到的问题描述,希望对你有所帮助。首先,你需要创建一个配置数据库的配置文件...
  • Java中使用Statement接口SQL语句

    千次阅读 2016-07-02 22:14:22
    Statement执行SQL语句: 1. 对数据库的曾删改操作时,使用stmt.executeUpdate(sql 执行给定 SQL 语句,分别为 insert 、update、delete. 2. 对数据库做查询时,直接使用 stmt.executeQuery(sql),返回结果...
  • import java.sql.*; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class REGGY { /** * @param ...
  • nutz 直接运行sql语句 mysqlDao java

    千次阅读 2018-01-09 11:17:25
    * 运行sql语句 返回到一个nutz的model list里 * @param sql sql语句 * @param classOfT 模型类名 * @return 一个pojo列表 */ public static <T> List<T> excuteSql (String sql, Class<T> ...
  • SQL语句操作MYSQL数据库和数据表
  • Java学习篇之SQL语句操作数据表中的数据(增删改)
  • mybatis批量删除sql语句拼接 1。问题描述 在删除一条语句时,有时候会关联外键,这时候批量删除会大大的提高效率。 2。拼接语句 <!--DELETE FROM hscs_itf_defination_lines WHERE HEADER_ID in(15,16);-->...
  • 在没有使用Hibernate框架的时候 ,每次在编写连接数据库查询的时候,都一直Ctrl +C,Ctrl +V 使用很多重复的sql语句,比如数据库的增删改查,造成代码的 数量冗余了很多,现在我整理一些 简化后适用的 ,我遇到的...
  • ►JDBC (Java DatabaseConnectivity) 是用于执行SQL 语句Java 应用程序接口,由一组用Java 语言编写的类和接口组成。 ►JDBC 是一种规范,各数据库厂商为Java 程序员提供标准的数据库访问类和接口,使得独立于...
  • 成品类 package ConnectMySql;...import java.sql.*; class ConnMySQL02ByExecute { private String driver; private String url;aa private String usename1; private String password; private C...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 162,216
精华内容 64,886
热门标签
关键字:

java执行删除sql语句

java 订阅