自建java程序实现SQL语句独立

自建java程序实现SQL语句独立

自建java程序实现SQL语句独立

Java中实现SQL语句与主程序分离的工具，该程序具有变通性强、可检错、可注释性、网络会话值获取、自生随机字符串、空置输出、系统时间获取。
Java中实现前端提交数据获取封装为json数据格式。
Java实现前端文件数据提取封装为fileitem数8据文件。
Java实现数据库连接操作类（独立实现与主程序分离）。
springboot配置文件另类用法（实现程序中加载配置文件内容）
Java中xml文件读取实现配置文件的方法。
Java实现AI控制加载器脚本（类似于JS脚本语言运行方式）实数据分析加载。
聊天文件操作器写入与读取

步骤说明

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：
1、新建一个maven项目（建议使用IDEA）
2、在maven项目下新建一个spring boot项目
3、在springboot下的pom.xml加入依赖包
4、编写SQL语句读取工具
5、编写前端传回数据分析工具
6、编写接口工具间；

代码分享

项目打包文件下载（ZIP）QQ：528409336

1、建立数据库连接操作类MySQL（用于执行SQL语句命令）

package poneco.sql.Database.serviceData;

import poneco.sql.Database.comm.ReadConfigData;
import poneco.sql.Database.comm.XMLPath;

import java.sql.*;
import java.util.Random;
import java.util.logging.Logger;


/**
 * MySQL类查询操作提供的的接口以及必须加载的数据
 *
 */
public class MySQL implements XMLPath {
    private ResultSet rst;
    private Connection con;
    private Statement stm;
    private String SQL;
    private ReadConfigData readConfigData = new ReadConfigData(configPath);
    Logger logger=Logger.getLogger(String.valueOf(MySQL.class));
    public void setSQL(String SQL){
        this.SQL = SQL;
    }
    /**
     * 数据库建表、数据删除、数据更新修改、数据添加操作函数
     * @return
     */
    public boolean Operation(){
        boolean alex = false;
        try {
            /*加载数据库连接驱动*/
            selverlet();
            String[] STQL = SQL.split(";");
            for (int i=0;i<STQL.length;i++){
                if(stm.executeUpdate(STQL[i])>0){
                    alex=true;
                }else {
                    alex = false;
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();

        }finally {
            Close();
        }
        return alex;
    }

    /**
     * 获取查询数据的结果集
     * @return 返回查询结果集
     */
    public ResultSet getRst(){
        try {
            /*加载数据库连接驱动*/
            selverlet();
            System.out.println(SQL);
            rst = stm.executeQuery(SQL);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return rst;
    }
    /**
     * 数据库连接关闭操作
     */
    public void Close(){
        try {
            if (con!=null){
                con.close();
            }
            if(stm!=null){
                stm.close();
            }
            if(rst!=null){
                rst.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    /**
     * 数据库连接加载
     */
    private void selverlet(){
        try {
            Class.forName(readConfigData.getConfigData("driver"));
            con = DriverManager.getConnection(readConfigData.getConfigData("url"),readConfigData.getConfigData("username"),readConfigData.getConfigData("password"));
            stm = con.createStatement();
            logger.info("数据库连接成功日志：");
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
            logger.info("数据库连接失误日志："+e.toString());
        }
    }
    public String getID(int number){
        String alex = "";
        Random ran = new Random();
        for(int i=0;i<number;i++){
            alex += ran.nextInt(10);
        }
        return alex;
    }
}

建立项目配置文件接口XMLPath

package poneco.sql.Database.comm;

public interface XMLPath {
    String path = "doc/userSQL.xml";//SQL语句存储位置
    String configPath="doc/userApplation.yml";//表示配置文件位置
}

/**
配置文档doc/userApplation.yml
url=jdbc:mysql://39.106.80.14:3306/poneco?useUnicode=true&characterEncoding=utf-8&useSSL=false
###数据库连接用户名
username=root
###数据库连接密码
password=7777777
driver=com.mysql.jdbc.Driver
SQL语句存储库

    
    select * from userTable where userID={userID} and userPass={password}
    
    insert into userTable(userID,userPass) values({userID} ,{password} )
    
    select * from BarTable where BarID like {search%} or BarName like {search%}
    
    select * from BarTable
    
    insert into OrderTable(OrderID,ID,admitID,OrderStartTime,OrderState,OrderSocre) values({autoID$20} ,{session$userID} ,{admitID} ,{autoTime} ,'待下单','0.0'); insert into OrderBarTable(OrderID,BarID,Count) values({agoAutoID} ,{BarID} ,{Count} )
    
    insert into OrderBarTable(OrderID,BarID,Count) values({agoAutoID} ,{BarID} ,{Count} )
    
    select OrderID from OrderTable where admitID={admitID} and OrderState='待下单'

**/

建立数据库配置文件加载类ReadConfigData

package poneco.sql.Database.comm;

import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;

import java.io.*;

public class ReadConfigData {
    private String ConfigPath;//数据库配置文件

    /**
     * 构造加载函数
     * @param ConfigPath 配置文件的地址
     */
    public ReadConfigData(String ConfigPath){
        this.ConfigPath = ConfigPath;
        setFile();//如果配置文件不存在责加载创建配置文件
    }

    /**
     * 获取配置文件数据
     * @param ConfigName 配置文件中数据的名称
     * @return 返回配置数据
     */
    public String getConfigData(String ConfigName){
        String ConfigData = null;
        try {
            Configuration config = new PropertiesConfiguration(ConfigPath);
            ConfigData = config.getString(ConfigName);
        } catch (ConfigurationException e) {
            ConfigData = getConfigData(ConfigName);
            e.printStackTrace();
        }
        return ConfigData;
    }

    /**
     * 创建不存在的数据文件
     */
    private void setFile(){
        File file = new File(ConfigPath);
        if(!file.exists()){
            OutputStream out = null;
            BufferedWriter bw = null;
            try {
                out = new FileOutputStream(file);
                bw = new BufferedWriter(new OutputStreamWriter(out, "utf-8"));
                bw.write("");
                bw.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    out.close();
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

建立SQL语句文件加载工具（使用xml文件作为管理sql语句管理方式）XMLRead

package poneco.sql.Database.comm;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

/**
 * XML文件读取获取数据
 * @author Administrator
 *
 */
public class XMLRead{
    private String SQLPath;
    public XMLRead(String configPath) {
        SQLPath = configPath;
    }
    public String getValue(String idName) {
        String alex = null;
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder db = dbf.newDocumentBuilder();
            Document doc = db.parse(SQLPath);
            Element root = doc.getDocumentElement();
            NodeList nl = root.getElementsByTagName(idName);
            Element e = (Element) nl.item(0);
            alex=e.getTextContent();
        }
        catch(Exception e){
            e.printStackTrace();
            System.out.println("注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意注意\n你可能没有配置SQL语句的XML文档数据，所以我找不到你指定的标签！");
        }
        return alex;
    }
}

新建一个数据分析整合器Analysis

package poneco.sql.Database.analysisData;

import org.springframework.boot.configurationprocessor.json.JSONArray;
import org.springframework.boot.configurationprocessor.json.JSONException;
import poneco.sql.Database.comm.XMLRead;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * SQL语句文件解析器加载
 * SQL语句关键词总结
 * 查询语句select {需要查询的内容} from {表名称} where {查询条件}
 * 删除语句delete from {表名} where {删除条件}
 * 增加语句inert into {表名({需要操作的列名}) values({输入的数据值})
 * update {表名} {列名}={输入的修改值} set where {修改条件}
 * 重点SQL语句中各个关键词要用空格隔开
 */

/**
 * DOM方式解析xml
 */
public class Analysis extends autoSystem {
    private XMLRead xmlRead = null;
    public void setJOSN(JSONArray JOSN) {
        this.JOSN = JOSN;
    }
    private JSONArray JOSN;//定义一个存储查询语句的JSON数据
    private String SQL;//定义一个SQL语句存储值
    private String agoAutoID=null;
    private HttpServletRequest request;
    /**
     * 构造函数加载SQL语句文件位置，以及获取传入的JSON数据
     * @param xmlPath  SQL文件位置
     */
    public Analysis(String xmlPath,JSONArray JOSN){
        this.xmlRead = new XMLRead(xmlPath);
        this.JOSN = JOSN;
        File file = new File(xmlPath.substring(0,xmlPath.lastIndexOf("/")));
        if(file.mkdirs()){
        }
        File file0 = new File(xmlPath);
        if(!file0.exists()){
            try {
                if(file0.createNewFile()){
                    System.out.println("当前你还没有建立相关文件我们已经为你建立好了，你去添加数据吧");
                }else {
                    System.out.println("注意注意注意注意注意注意注意\n！文件创建失败啦！");
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("注意注意注意注意注意注意注意\n系统出问题了！请你检查系统");
            }
        }else{
            System.out.println("注意注意注意注意注意注意注意\n！你已经创建过文件了");
        }
    }
    /**
     * 提供外部需要的SQL语句
     * @param idName  SQL语句再SQL文件中储存的名称
     * @return  返回SQL语句
     */
    public String getSQL(String idName){
        SQL = xmlRead.getValue(idName);
        List list = getUseValue(SQL);
        String str0;
        String xt="";
        System.out.println(SQL);
        try {
            for(Object ignored : list){
                xt = ignored.toString();
                /*提取字符串数据名称控制器加载输出名称str0*/
                /*存储SQL语句中的查询条件值*/
                if(xt.equals("{autoTime}")){
                    str0 ="'"+getSystemTime("yyy-MM-dd")+"'";//拼接加载SQL语句
                }else if(xt.indexOf("autoID")>0){
                    str0 = "'"+getRan(Integer.parseInt(getRemark(xt)))+"'";//拼接加载SQL语句
                    agoAutoID = str0;
                }else if(xt.indexOf("session")>0){
                    str0 = "'"+ getSession(this.request,getRemark(xt))+"'";
                }else if(xt.equals("{!}")){
                    str0="'0'";
                } else if(xt.indexOf("%")>0){
                    str0 = "'"+this.JOSN.getJSONObject(0).getString(xt.substring(xt.indexOf("{")+1,xt.indexOf("%")))+"%'";//模糊查询功能
                } else if(xt.indexOf("agoAutoID")>0){
                    str0 = "'"+agoAutoID.replace("'","")+"'";
                } else if(xt.indexOf("{")!=-1&&xt.indexOf("}")!=-1){
                    str0 = "'"+this.JOSN.getJSONObject(0).getString(xt.substring(xt.indexOf("{")+1,xt.indexOf("}")))+"'";
                } else{
                    str0=" ";
                }
                if(xt.indexOf("{")!=-1&&xt.indexOf("}")!=-1){
                    SQL = SQL.replace(xt,str0);//拼接加载SQL语句
                }
            }
        } catch (JSONException e) {
            e.printStackTrace();
            System.out.println("报错的我好伤心！...");
        }
        System.out.println(SQL);
        return SQL;
    }

    /**
     * 解析字符串中需要更改的数据项
     * 语法{字符名}
     * @param str SQL语句的字符串
     * @return
     */
    private List<String> getUseValue(String str){
        List<String> list = new ArrayList();
        String[] str0 = str.split(" ");
        for(int i=0;i<str0.length;i++){
            System.out.println(str0[i].indexOf("{"));
            if(str0[i].indexOf("{")>0||str0[i].indexOf("{")==0){
                String str1 = str0[i].substring(str0[i].indexOf("{"),str0[i].length());
                list.add(str1);
            }
        }
        return list;
    }
    public void setRequest(HttpServletRequest request){
        this.request = request;
    }
}

建立需要由系统自动工厂生产数据的工具autoSystem

package poneco.sql.Database.analysisData;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;

public class autoSystem {
    /**
     * 自动加载随机参数
     * @param Length
     * @return
     */
    public String getRan(int Length){
        String alex = "";
        Random ran = new Random();
        for(int i=0;i<Length;i++){
            alex = alex + ran.nextInt(10);
        }
        return alex;
    }

    /**
     * 获取系统时间
     * @param TimeType
     * @return
     */
    public String getSystemTime(String TimeType){
        String alex = null;
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(TimeType);//设置时间格式
        alex = simpleDateFormat.format(new Date());
        return alex;
    }

    /**
     * 获取自动会话值
     * @param request
     * @param sessionName
     * @return
     */
    public String getSession(HttpServletRequest request,String sessionName){
        String alex = null;
        HttpSession session = request.getSession();
        alex = (String)session.getAttribute(sessionName);
        System.out.println(alex);
        return alex;
    }

    /**
     * 获取自动命令
     * @param str
     * @return
     */
    public String getRemark(String str){
        String alex=null;
        alex = str.substring(str.indexOf("$")+1,str.length()-1);
        return alex;
    }
}

建立配置一个前端数据接收器（最终将数据封装成为JSON格式数据不支持文件上传接受）dataRead

package poneco.sql.Database.requestData;

import com.google.gson.Gson;
import org.springframework.boot.configurationprocessor.json.JSONArray;

import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.util.*;

/**
 * 前段数据获取层
 * @author 杨鹏飞
 *
 */
public class dataRead {
    /**
     * 取出所有传输的数据
     * @param request 请求数据
     * @return
     */
    private Map map = new HashMap();
    public JSONArray getData(HttpServletRequest request){
        try {
            request.setCharacterEncoding("UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        List list = new ArrayList();
        JSONArray jsonArray=null;
        Enumeration enu=request.getParameterNames();
        while(enu.hasMoreElements()){
            String paraName=(String)enu.nextElement();
            if(request.getParameter(paraName)==""){
                break;
            }else {
                map.put(paraName,request.getParameter(paraName));
            }
        }
        list.add(map);
        Gson gson = new Gson();
        try {
            jsonArray = new JSONArray(gson.toJson(list));
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(jsonArray);
        return jsonArray;
    }
}

创建中间层统筹整个功能的实现（接触数据库操作接壤与前端接口这里实现一个注册的方法）Register

package poneco.sql.domain;

import com.google.gson.Gson;
import poneco.sql.Database.analysisData.Analysis;
import poneco.sql.Database.comm.XMLPath;
import poneco.sql.Database.requestData.dataRead;
import poneco.sql.Database.serviceData.MySQL;

import javax.servlet.http.HttpServletRequest;


/**
 * 用户注册实现类
 */
public class Register implements XMLPath {
    private HttpServletRequest request;
    private MySQL SQL = new MySQL();
    public Register(HttpServletRequest request) {
        this.request = request;
    }

    /**
     * 实际执行函数
     * @return
     */
    public boolean alex() {
        boolean xc;
        dataRead dataRead = new dataRead();
        Analysis analysis = new Analysis(path,dataRead.getData(request));
        SQL.setSQL(analysis.getSQL("userRegister"));
        xc=SQL.Operation();
        return xc;
    }
}

网络服务提供层userInformation

package poneco.sql.api;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import poneco.sql.domain.Register;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 订单下单网络接口
 */
@RestController
@RequestMapping(value = "/user",method = { RequestMethod.GET, RequestMethod.POST })
public class userInformation {
    @Autowired
    private HttpServletRequest request;
    @Autowired
    private HttpServletResponse response;
    /**
     * 用户注册
     *
     *
     *
     * @return
     */
    @RequestMapping("/Register")
    @ResponseBody
    public boolean userRegister(){
        Register register = new Register(request);
        return register.alex();
    }
}

pom.xml配置文件依赖包

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
        <dependency>
            <groupId>commons-configuration</groupId>
            <artifactId>commons-configuration</artifactId>
            <version>1.10</version>
        </dependency>
    </dependencies>