作者简介：全栈开发工程，从事Java、Python、前端、小程序方面的开发和研究，对大数据应用与开发比较感兴趣，
主要内容：Java项目、前端项目、Python项目、小程序开发、大数据项目、单片机
收藏点赞不迷路 关注作者有好处
文末获取源码
感谢您的关注，请收藏以免忘记，点赞以示鼓励，评论给以建议，爱你哟
项目编号：BS-GX-069
一，环境介绍
语言环境：Java: jdk1.8
数据库：Mysql: mysql5.7
应用服务器：Tomcat: tomcat8.5.31
开发工具：IDEA或eclipse
开发技术：Javaweb
二，项目简介
本项目基于Javaweb开发实现一个校园疫情管理系统。系统设计的参与人员角色总共有三类：学生、教师、管理员。学生可以在线注册信息，教师由管理员分配账户，管理员由系统初始化指定。
学生登录系统可以在线申请离校和返校，提交个人体温数据，管理个人资料信息。老师登录系统可以对学生提交的信息进行审批，也可以上报自己的健康体温数据并修改个人信息。管理员登录系统后可对学生、教师、学院、专业、班级信息进行基础数据管理，并可以管理学生和教师上报的健康信息，管理入校和离校的申请信息，并统计离校人员数量。具体见下面展示。
三，系统展示
用户登录
管理员管理
学生信息管理
教职工管理
学院管理
专业管理
班级管理
健康和体温采集管理
入校申请管理
离校申请管理
离校统计
四，核心代码展示
package dao;
import util.threadlocal.LocalRequestContext;
import util.threadlocal.LocalRequestContextHolder;
import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
/**
* 继承自ArrayList 的实现，并实现分页代码的展示
* @param <E>
*/
public class Collect<E> extends ArrayList<E> {
// 总数
protected long count = 0;
// 当前分页
protected int page = -1;
// 分页总数
protected int pageCount = 0;
// 第一行起始位置 limit firstRow,listRows 即可
public int firstRow = 0;
// 取数据库的行数
public int listRows = 15;
// URL 规则
protected String urlRule = "";
// 表现层代码
private String info;
private Collect()
{
}
public String getUrlRule() {
return urlRule;
}
public String getInfo() {
return info;
}
/**
*
* @param count 总行数
* @param pagesize 一页展示多少条数据
*/
public Collect(long count , int pagesize )
{
this.listRows = pagesize;
this.count = count;
this.initLimit();
}
/**
*
* @param count 总行数
* @param pagesize 一页展示多少条数据
* @param page 当前页
*/
public Collect(long count , int pagesize , int page )
{
this.listRows = pagesize;
this.count = count;
this.page = page;
this.initLimit();
}
/**
* 初始化
*/
protected void initLimit()
{
// 取分页数有多少
double ceil = (double) this.count / (double)this.listRows;
// 分页页面总数
this.pageCount = this.count == 0 ? 0 : new Double(Math.ceil(ceil)).intValue();
// 取URL 规则
this.urlRule = getRequestUrlPath();
// 获取第一行的位置
firstRow = listRows*(page-1);
// 渲染分页代码
info = reader();
// 获取当前线程的Request
LocalRequestContext content = LocalRequestContextHolder.getLocalRequestContext();
HttpServletRequest res = content.getRequest();
// 赋值给模版，模版采用 ${info.page} 即可显示分页
HashMap p = new HashMap();
p.put("info" , info);
//PageCollect p = new PageCollect();
//p.setInfo(info);
res.setAttribute("page" , p);
}
public long getCount()
{
return count;
}
public void setCount(long c)
{
this.count = c;
}
/**
* 渲染页面展示函数
* @return
*/
public String reader()
{
// 初始化字符串缓冲区
StringBuffer buffer = new StringBuffer();
// 替换URL 规则
String url = urlRule.replace("page={page}" , "");
// 生成表单
buffer.append("<form action=\""+url+"\" method=\"get\"><div class=\"pages\">");
buffer.append("<span>共").append(this.count).append("条").append(" ");
buffer.append(this.page).append("/").append(this.pageCount).append("页</span>");
// 渲染第一页
getFirstPage(buffer);
// 渲染上一页
getPrevPage(buffer);
// 渲染页码 如： 1 2 3 4 5 这样
getCenterPage(buffer);
// 渲染下一页
getNextPage(buffer);
// 渲染最后一页
getLastPage(buffer);
// 渲染下拉框
getSelect(buffer);
buffer.append("</div></form>");
//int currentPage = ;
// 返回渲染好的HTML 代码
return buffer.toString();
}
/**
* 渲染下拉框
* @param buffer
*/
protected void getSelect(StringBuffer buffer)
{
buffer.append("<select name=\"page\" onchange=\"this.form.submit()\">");
for(int i=1;i<=pageCount;i++){
buffer.append("<option value='"+i+"'"+(page==i?" selected":"")+">"+i+"</option>");
}
buffer.append("</select>");
}
/**
* 渲染页码 如1、2、3、4、5
* @param buffer
*/
protected void getCenterPage(StringBuffer buffer)
{
// 取中间页面
int rollPage = 2;
int show_nums = rollPage * 2 +1;
int i=0;
if(pageCount <= show_nums){
for(i = 1;i<=pageCount;i++){
if(i == this.page){
buffer.append("<a href=\"javascript:;\" class=\"active\">"+i+"</a>");
}else{
buffer.append("<a href=\"").append(this.getUrlPath(i)).append("\">"+i+"</a>");
}
}
}else if(page < (1+rollPage)){
for(i = 1;i<=show_nums;i++){
if(i == page){
buffer.append("<a href=\"javascript:;\" class=\"active\">"+i+"</a>");
}else{
buffer.append("<a href=\"").append(this.getUrlPath(i)).append("\">"+i+"</a>");
}
}
}else if(page >= (pageCount - rollPage)){
for(i = pageCount - show_nums ; i <= pageCount ; i++){
if(i == page){
buffer.append("<a href=\"javascript:;\" class=\"active\">"+i+"</a>");
}else{
buffer.append("<a href=\"").append(this.getUrlPath(i)).append("\">"+i+"</a>");
}
}
}else{
int start_page = page - rollPage;
int end_page = page + rollPage;
for(i = start_page ; i<=end_page ; i++){
if(i == page){
buffer.append("<a href=\"javascript:;\" class=\"active\">"+i+"</a>");
}else{
buffer.append("<a href=\"").append(this.getUrlPath(i)).append("\">"+i+"</a>");
}
}
}
}
/**
* 渲染第一页
* @param buffer
*/
protected void getFirstPage(StringBuffer buffer)
{
buffer.append("<a href=\"").append(this.getUrlPath(1)).append("\">第一页</a>");
}
/**
* 渲染上一页
* @param buffer
*/
protected void getPrevPage(StringBuffer buffer)
{
if(this.page == 1){
getDisabledButton(buffer , "上一页");
}else{
buffer.append("<a href=\"").append(getUrlPath(this.page - 1)).append("\">上一页</a>");
}
}
/**
* 渲染下一页
* @param buffer
*/
protected void getNextPage(StringBuffer buffer)
{
if(this.page < this.pageCount)
{
buffer.append("<a href=\"").append(getUrlPath(this.page + 1)).append("\">下一页</a>");
}else{
getDisabledButton(buffer , "下一页");
}
}
/**
* 渲染最后一页
* @param buffer
*/
protected void getLastPage(StringBuffer buffer)
{
buffer.append("<a href=\"").append(this.getUrlPath(this.pageCount)).append("\">尾页</a>");
}
/**
* 渲染不可点的按钮
* @param buffer
* @param name
*/
protected void getDisabledButton(StringBuffer buffer , String name)
{
buffer.append("<a href='javascript:;' class=\"disabled\">").append(name).append("</a>");
}
/**
* 获取替换成功的页码
* @param page
* @return
*/
protected String getUrlPath(int page)
{
return this.urlRule.replace("{page}" , String.valueOf(page));
}
/**
* 根据当前页面生成URL规则，
* @return
*/
protected String getRequestUrlPath()
{
// 获取当前线程的Request
LocalRequestContext context = LocalRequestContextHolder.getLocalRequestContext();
// 取 URL 后面的参数如： a=b&b=c&d=e
String queryString = context.getRequest().getQueryString();
if(queryString == null){
queryString = "";
}
// 创建缓冲区
StringBuffer buffer = new StringBuffer(queryString.length()+16);
// 获取URL path 参数如： /index.jsp
String requestURI = context.getRequest().getRequestURI();
// 开始写入参数
buffer.append(requestURI).append("?");
// 获取URL提交的参数
Map<String,String[]> param = context.getRequest().getParameterMap();
String name = "";
String value = "";
// 是否搜索page 参数
boolean isSearchPage = false;
int page = -1;
for (Map.Entry<String, String[]> entry : param.entrySet()) {
try{
name = entry.getKey();
String[] values = entry.getValue();
// 当前参数等于=page
if(name.equals("page")){
page = Integer.valueOf(values[0]).intValue();
// 写入url 规则的是：page={page} 使用时替换{page}即可
buffer.append(name).append("=").append("{page}").append("&");
isSearchPage = true;
} else if (null == values) {
// 值等于null,所以也写入
buffer.append(name).append("=").append("&");
} else if (values.length>1) {
// 同名参数，多个
for (int i = 0; i < values.length; i++) { //用于请求参数中有多个相同名称
value = URLEncoder.encode(values[i] , "UTF-8");
buffer.append(name).append("=").append(value).append("&");
}
//value = value.substring(0, value.length() - 1);
} else {
value = URLEncoder.encode(values[0] , "UTF-8");
buffer.append(name).append("=").append(value).append("&");//用于请求参数中请求参数名唯一
}
}catch (UnsupportedEncodingException e){
e.printStackTrace();
}
}
// 写入当前页码
if(this.page == -1){
this.page = page;
}
// 防止page 小于1
this.page = Math.max(this.page , 1);
// 没有搜索到页码直接写入
if(!isSearchPage){
buffer.append("page={page}&");
}
String result = buffer.toString();
return result.substring(0 , result.length()-1);
}
public int getPage() {
return page;
}
}
package dao;
import dao.db.Builder;
import util.Info;
import util.StringUtil;
import java.sql.*;
import java.util.*;
/**
* 操作数据库链式执行
* 目前只实现了部分方法，之后会继续完善该代码,让其支持实体类的数据获取
* 使用方法：Query.make("表名称").where("字段名" , "条件符号","条件值").select()
*
*/
public class Query {
protected String mName = "";
protected HashMap mOption = null;
protected String pk = "id";
protected HashMap mData = null;
protected Builder builder = null;
public static HashMap tableFields = new HashMap();
public Query()
{
reset();
}
/**
* 构造Query
* @param name
*/
public Query(String name)
{
reset();
setName(name);
}
/**
* 重置并初始化数据
* @return
*/
protected Query reset()
{
mName = "";
mOption = null;
mOption = new HashMap();
mData = new HashMap();
builder = Builder.make(new CommDAO().getConn());
if(tableFields == null)
{
tableFields = new HashMap();
}
return this;
}
/**
* 设置一个字段自增
* @param field
* @param step
* @return
*/
public Query inc(String field , int step)
{
if(step<1)step = 1;
ArrayList list = new ArrayList();
list.add("inc");
list.add(step);
mData.put(field , list);
return this;
}
/**
* 设置一个字段自减
* @param field
* @param step
* @return
*/
public Query dec(String field , int step)
{
if(step<1)step = 1;
ArrayList list = new ArrayList();
list.add("dec");
list.add(step);
mData.put(field , list);
return this;
}
/**
* 马上更新数据字段自增1
* @param field
* @return
*/
public boolean setInc(String field)
{
return setInc(field ,1);
}
/**
* 马上更新数据字段自增step
* @param field
* @param step
* @return
*/
public boolean setInc(String field , String step)
{
return inc(field , Integer.valueOf(step).intValue()).update();
}
/**
* 马上更新数据字段自增step
* @param field
* @param step
* @return
*/
public boolean setInc(String field , int step)
{
return inc(field , step).update();
}
/**
* 马上更新数据字段自减1
* @param field
* @return
*/
public boolean setDec(String field )
{
return setDec(field , 1);
}
/**
* 马上更新数据字段自减step
* @param field
* @param step
* @return
*/
public boolean setDec(String field , String step)
{
return dec(field , Integer.valueOf(step).intValue()).update();
}
/**
* 马上更新数据字段自减step
* @param field
* @param step
* @return
*/
public boolean setDec(String field , int step)
{
return dec(field , step).update();
}
/**
* 设置某字段为某个值，并更新
* @param field
* @param step
* @return
*/
public boolean setField(String field , Object step)
{
mData.put(field , step);
return update();
}
/**
* 获取当前写入的data
* @return
*/
public HashMap getData()
{
return mData;
}
/**
* 更新当前数据
* @return
*/
public boolean update()
{
return update(null);
}
/**
* 更新当前数据加写入的data
* @param updateData
* @return
*/
public boolean update( HashMap updateData )
{
if(updateData != null){
mData.putAll(updateData);
}
String sql = builder.buildUpdate(this);
executeInsert(sql);
return true;
}
/**
* 向query 写入data
* @param data
* @return
*/
public Query data(Map data)
{
mData.putAll(data);
return this;
}
/**
* 向当前query 写入data
* @param name
* @param value
* @return
*/
public Query data(String name , String value)
{
mData.put(name , value);
return this;
}
/**
* 向当前query 写入data
* @param name
* @param value
* @return
*/
public Query data(String name , int value)
{
mData.put(name , value);
return this;
}
/**
* 向当前query 写入data
* @param name
* @param value
* @return
*/
public Query data(String name , long value)
{
mData.put(name , value);
return this;
}
/**
* 向当前query 写入data
* @param name
* @param value
* @return
*/
public Query data(String name , float value)
{
mData.put(name , value);
return this;
}
/**
* 向当前query 写入data
* @param name
* @param value
* @return
*/
public Query data(String name , double value)
{
mData.put(name , value);
return this;
}
/**
* 向当前query 写入data
* @param name
* @param value
* @return
*/
public Query data(String name , boolean value)
{
mData.put(name , value ? 1 : 0);
return this;
}
/**
* 插入数据
* @param insertData
* @return
*/
public int insert(HashMap insertData ){ return insert(insertData , false); }
/**
* 插入数据
* @param insertData
* @param replace
* @return
*/
public int insert(HashMap insertData , boolean replace)
{
if(insertData != null){
mData.putAll(insertData);
}
String sql = builder.buildInsert(this , replace);
return executeInsert(sql);
}
/**
* 获取当前自增字段名称
* @return
*/
public String getPk() {
return pk;
}
/**
* 设置自增字段名
* @param pk
*/
public void setPk(String pk) {
this.pk = pk;
}
/**
* 尚未实现该代码，获取表的数据
*/
protected void finalize()
{
//Statement st = conn.createStatement();
//System.out.print(sql);
//ResultSet rs
//super.finalize();
free();
}
/**
* 释放资源
*/
public void free()
{
// 释放rs
for(int i=0;i<resultSetList.size();i++){
Object os = resultSetList.get(i);
try{
if(os instanceof Statement){
Statement st = ((Statement) os);
st.close();
}else if(os instanceof ResultSet){
((ResultSet) os).close();
}
}catch (SQLException e){
}
}
resultSetList.clear();
}
/**
* 设置表名称
* @param name
* @return
*/
public Query setName(String name)
{
mName = name;
return this;
}
/**
* 获取表名称
* @return
*/
public String getName()
{
return mName;
}
/**
* 设置属性
* @param name
* @param value
* @return
*/
public Query setAttribute(String name , Object value)
{
getOptionHashMap("data").put(name , value);
return this;
}
/**
* 获取属性
* @param name
* @return
*/
public Object getAttribute(String name)
{
return getOptionHashMap("data").get(name);
}
/**
* 设置字段为 获取所有字段
* @return
*/
public Query field()
{
return field("*");
}
/**
* 设置字段，可以用","逗号隔开多个
* @param field
* @return
*/
public Query field(String field)
{
getOptionArrayList("field").add(field);
return this;
}
/**
* 设置表
* @param nTable
* @return
*/
public Query table(String nTable)
{
getOptionArrayList("table").add(nTable);
return this;
}
/**
* 设置表
* @param nTable
* @return
*/
public Query table(String nTable , String alias)
{
getOptionArrayList("table").add(nTable+" "+alias);
return this;
}
/**
* 设置行数
* @param nLimit
* @return
*/
public Query limit(int nLimit)
{
//getOptionHashMap("limit").put("limit" , String.valueOf(nLimit));
return limit(String.valueOf(nLimit));
}
/**
* 设置起始行和行数
* @param offset
* @param nLimit
* @return
*/
public Query limit(int offset , int nLimit)
{
return limit(String.valueOf(offset) , String.valueOf(nLimit));
}
/**
* 设置是否锁表
* @param lock
* @return
*/
public Query lock( boolean lock )
{
return this.lock(lock ? " FOR UPDATE " : "");
}
/**
* 设置锁表代码
* @param lock
* @return
*/
public Query lock(String lock)
{
getOption().put("lock" , lock);
return this;
}
/**
* 设置行数，字符串形式
* @param nLimit
* @return
*/
public Query limit(String nLimit)
{
if(nLimit.indexOf(",") != -1){
String[] list = nLimit.split(",");
return limit(list[0] , list[1]);
}
getOptionHashMap("limit").put("limit" , nLimit);
return this;
}
/**
* 设置起始行和行数
* @param offset
* @param nLimit
* @return
*/
public Query limit(String offset , String nLimit)
{
HashMap map = getOptionHashMap("limit");
map.put("limit" , nLimit);
map.put("offset" , offset);
return this;
}
/**
* 根据ID 获取一行数据
* @param id
* @return
*/
public HashMap find(int id)
{
where(pk , String.valueOf(id));
return find();
}
/**
* 根据ID 获取一行数据
* @param id
* @return
*/
public HashMap find(String id)
{
where(pk , id);
return find();
}
/**
* 根据当前条件获取一行数据
* @return
*/
public HashMap find()
{
//limit(1);
String sql = builder.buildSelect(this);
ResultSet rs = query(sql);
QueryData data = fetch(rs);
return data;
}
/**
* 生成统计计算语句
* @param f
* @param func
* @return
*/
protected double total(String f , String func)
{
String ifnull = builder.parseIfNull(func+"("+f+")" , "0");
String field = ifnull+" count";
if(mOption.containsKey("field")){
getOptionArrayList("field").clear();
}
getOptionArrayList("field").add(field);
HashMap data = find();
if(data.containsKey("count")){
String count = data.get("count").toString();
return Double.valueOf(count).doubleValue();
}
return 0;
}
/**
* 求某字段和
* @param field
* @return
*/
public double sum(String field)
{
return total(field , "SUM");
}
/**
* 求某字段的平均值
* @param field
* @return
*/
public double avg(String field)
{
return total(field , "AVG");
}
/**
* 求最大值
* @param field
* @return
*/
public double max(String field){
return total(field , "MAX");
}
/**
* 求最小值
* @param field
* @return
*/
public double min(String field)
{
return total(field , "MIN");
}
/**
* 求数据行数
* @return
*/
public long count()
{
return count(null);
}
/**
* 根据字段名求数据行数
* @return
*/
public long count( String field )
{
if(field == null){
if(mOption.containsKey("alias")){
field = "count("+mOption.get("alias")+".id) count";
}else{
field = "count(*) count";
}
}else{
field = "count("+field+") count";
}
if(mOption.containsKey("field")){
mOption.put("field" , new ArrayList());
//getOptionArrayList("field").clear();
}
if(mOption.containsKey("order")){
mOption.remove("order");
}
getOptionArrayList("field").add(field);
HashMap data = find();
if(data.containsKey("count")){
return Long.valueOf((String)data.get("count")).longValue();
}
return 0;
}
/**
* 根据列表id 删除数据
* @param ids
* @return
*/
public long delete(List ids)
{
where(getPk() , "in" , ids);
return delete();
}
/**
* 根据id 删除数据
* @param id
* @return
*/
public long delete(int id)
{
where(getPk() , id);
return delete();
}
/**
* 根据id 删除数据
* @param id
* @return
*/
public long delete(String id)
{
if(id.indexOf(",")!=-1){
where(getPk() , "in" , id);
}else{
where(getPk() , id);
}
return delete();
}
/**
* 根据当前条件删除数据，如果没有条件则不执行删除
* @return
*/
public long delete()
{
if(!mOption.containsKey("where")){
return -1;
}
String sql = this.builder.buildDelete(this);
return executeUpdate(sql);
}
/**
* 根据当前条件获取数据集
* @return
*/
public ArrayList select()
{
ArrayList result = new ArrayList();
String sql = builder.buildSelect(this);
ResultSet rs = query(sql);
if (rs == null) {
return result;
}
QueryData data = null;
while( !((data = fetch(rs)).isEmpty()) ){
result.add(data);
}
return result;
}
/**
* 根据ResultSet 获取数据行
* @param rs
* @return
*/
public QueryData fetch(ResultSet rs)
{
QueryData data = new QueryData();
if(rs == null)return data;
try {
if(rs.next()){
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount();
for(int i=1;i<=columnCount;i++){
String name = rsmd.getColumnName(i);
String value = rs.getString(i);
if(value == null || value.toLowerCase().equals("null")){
value = "";
}
data.put(name , value);
}
}
}catch (SQLException sql){
sql.printStackTrace();
}
return data;
}
protected ArrayList resultSetList = new ArrayList();
/**
* 查询sql 语句并返回ResultSet，这个不需要释放，系统在释放时会自动释放
* @param sql
* @return
*/
public ResultSet query(String sql)
{
try {
Connection conn = this.getConn();
Statement st = conn.createStatement();
System.out.println(sql);
ResultSet rs = st.executeQuery(sql);
resultSetList.add(rs);
resultSetList.add(st);
return rs;
}catch (SQLException e){
int code = e.getErrorCode();
String message = e.getMessage();
System.err.println("SQL execute Error");
System.err.println("code:"+code);
System.err.println("Message:"+message);
//e.printStackTrace();
}
return null;
}
/**
* 根据当前条件获取一行数据中的某个字段的值
* @param name
* @return
*/
public String value(String name)
{
if(!mOption.containsKey("field")){
field(name);
}
HashMap data = find();
if(data.isEmpty()){
return "";
}
return String.valueOf(data.get(name));
}
/**
* 设置SQL 分组
* @param nGroup
* @return
*/
public Query group(String nGroup)
{
getOptionArrayList("group").add(nGroup);
return this;
}
/**
* 设置 SQL 排序字段
* @param nOrder
* @return
*/
public Query order(String nOrder)
{
getOptionArrayList("order").add(nOrder);
return this;
}
/**
* 设置SQL语句使用全连接 会生成如下：INNER JOIN table t on cond 的形式
* @param table
* @param cond 条件
* @return
*/
public Query joinInner(String table , String cond)
{
return join(table , cond , "INNER");
}
/**
* 设置sql 语句使用右连接 会生成如下：RIGHT JOIN table t on cond 的形式
* @param table
* @param cond
* @return
*/
public Query joinRight(String table , String cond)
{
return join(table , cond , "RIGHT");
}
/**
* 设置sql 语句使用左连接 会生成如下：table t on cond 的形式
* @param table
* @param cond
* @return
*/
public Query joinLeft(String table , String cond)
{
return join(table , cond , "LEFT");
}
/**
* 设置sql 语句使用右连接 会生成如下：type JOIN table t on cond 的形式
* @param table
* @param cond
* @param type 跨不会类型
* @return
*/
public Query join(String table , String cond , String type)
{
StringBuffer buffer = new StringBuffer();
buffer.append(" ").append(type).append(" JOIN ").append(table).append(" ON ").append(cond);
getOptionArrayList("join").add(buffer.toString());
return this;
}
/**
* 设置当前表的别名
* @param name
* @return
*/
public Query alias(String name)
{
mOption.put("alias" , name);
return this;
}
/**
* 获取设置参数
* @param type
* @return
*/
private HashMap getOptionHashMap(String type)
{
if(mOption.containsKey(type)){
return (HashMap) mOption.get(type);
}
HashMap map = new HashMap();
mOption.put(type , map);
return map;
}
/**
* 获取设置参数
* @param type
* @return
*/
private ArrayList getOptionArrayList(String type)
{
if(mOption.containsKey(type)){
return (ArrayList) mOption.get(type);
}
ArrayList map = new ArrayList();
mOption.put(type , map);
return map;
}
/**
* 设置SQL条件
* @param name
* @return
*/
public Query where(String name)
{
HashMap list = new HashMap();
list.put("where" , name);
getOptionArrayList("where").add(list);
return this;
}
/**
* 设置SQL条件 会自动写成 and name='value' 这样的形式
* @param name 字段名
* @param value 条件值
* @return
*/
public Query where(String name , Object value)
{
return where(name , null , value ,null);
}
/**
* 设置SQL条件 会自动写成 and name eq 'value' 这样的形式
* @param name
* @param eq 符号，可以写成：=、>、>=、<、<=、eq、neq、gt、egt、lt、elt
* @param value
* @return
*/
public Query where(String name ,String eq, Object value)
{
return where(name , eq , value ,null);
}
/**
* 设置SQL条件 会自动写成 and name eq 'value' 这样的形式
* @param name
* @param eq 符号，可以写成：=、>、>=、<、<=、eq、neq、gt、egt、lt、elt
* @param Value
* @param connect 连接符默认为：and
* @return
*/
public Query where(String name , String eq , Object Value , String connect)
{
HashMap list = new HashMap();
list.put("name",name);
list.put("exp" , eq == null ? "=" : eq);
list.put("value",Value == null ? "" : Value);
list.put("connect",connect == null ? "and" : connect);
getOptionArrayList("where").add(list);
return this;
}
/**
* 设置SQL条件 会自动写成 and field in(inArray) 这样的形式
* @param field
* @param inArray
* @return
*/
public Query whereIn(String field , String inArray)
{
String[] arr = inArray.split(",");
return where(field , "in" , arr);
}
/**
* 设置SQL条件 会自动写成 and field in(inArray1,inArray2) 这样的形式
* @param field
* @param inArray
* @return
*/
public Query whereIn(String field , Object inArray)
{
return where(field , "in" , inArray);
}
/**
* 设置SQL条件 会自动写成 and field not in(inArray1) 这样的形式
* @param field
* @param inArray
* @return
*/
public Query whereInNot(String field , Object inArray)
{
return where(field , "not in" , inArray);
}
/**
* 设置SQL条件 会自动写成 and field between inArray 这样的形式
* @param field
* @param inArray
* @return
*/
public Query whereBetween(String field , String inArray)
{
String[] arr = inArray.split(",");
return where(field , "between" , arr);
}
/**
* 设置SQL条件 会自动写成 and field between 'start' and 'end' 这样的形式
* @param field
* @param start
* @param end
* @return
*/
public Query whereBetween(String field , String start , String end)
{
return where(field , "between" , "'"+start+"' AND '"+end+"'");
}
/**
* 设置SQL条件 会自动写成 and field not between inArray 这样的形式
* @param field
* @param inArray
* @return
*/
public Query whereBetweenNot(String field , String inArray)
{
String[] arr = inArray.split(",");
return where(field , "not between" , arr);
}
/**
* 设置SQL条件 会自动写成 and field not between 'start' and 'end' 这样的形式
* @param field
* @param start
* @param end
* @return
*/
public Query whereBetweenNot(String field , String start , String end)
{
return where(field , "not between" , "'"+start+"' AND '"+end+"'");
}
/**
* 获取connection 连接
* @return
*/
protected Connection getConn()
{
return new CommDAO().getConn();
}
/**
* 根据字段类型生成默认值
* @param type
* @return
*/
protected String getFieldDefault(String type)
{
String t = type.toUpperCase();
if(t.equals("DATE")){
return "0000-00-00";
}else if(t.equals("DATETIME")){
return "0000-00-00 00:00:00";
}else if(t.equals("TIME")){
return "00:00:00";
}else if(t.equals("TIMESTAMP")){
return Info.getDateStr();
}else if(t.equals("FLOAT") || t.equals("DOUBLE") || t.equals("DECIMAL") || t.indexOf("INT")!=-1){
return "0";
}
return "''";
}
/**
* 设置字段信息防止xxs 注入
* @param type
* @param value
* @return
*/
protected String getFieldValue(String type , String value)
{
String t = type.toUpperCase();
if(value == null || value.equals("")){
// 等于空值，就写入默认值
return getFieldDefault(type);
}
if(t.equals("FLOAT") || t.equals("DOUBLE") || t.equals("DECIMAL") || t.indexOf("INT")!=-1){
return value;
}
return "'"+value.replace("'" , "\\'")+"'";
}
/**
* 获取表字段信息
* @param table
* @return
*/
protected HashMap getTableField(String table )
{
if(table == null){
table = mName;
}
if(tableFields.containsKey(table)){
return (HashMap) tableFields.get(table);
}
HashMap result = new HashMap();
try{
Connection conn = this.getConn();
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery("select * from " + table);
ResultSetMetaData rsmd = rs.getMetaData();
int i = rsmd.getColumnCount();
for (int j = 1; j <= i; j++) {
result.put(rsmd.getColumnName(j) , rsmd.getColumnTypeName(j));
}
rs.close();
st.close();
}catch (SQLException e){
e.printStackTrace();
}
return result;
}
/**
* 根据表字段生成键值 和 value值
* @param map 数据
* @param fields 空的字段信息
* @param values 空的value 值 也就是要写入的值，不需要传值
* @param isInsert 是否为插入，插入的话要写入默认值
*/
protected void getFieldValueList(HashMap map , ArrayList fields , ArrayList values , boolean isInsert)
{
try{
Connection conn = this.getConn();
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery("select * from " + mName);
ResultSetMetaData rsmd = rs.getMetaData();
int i = rsmd.getColumnCount();
for (int j = 1; j <= i; j++) {
String col =rsmd.getColumnName(j);
if (col.toLowerCase().equals("id")) continue;
String type = rsmd.getColumnTypeName(j);
if(map.containsKey(col)){
// 存在,就不理他了
fields.add(col);
values.add(getFieldValue(type ,String.valueOf(map.get(col))) );
}else{
// 插入的时候才将所有字段弄过去
if(isInsert){
fields.add(col);
values.add(getFieldDefault(type));
}
}
}
} catch (SQLException e) {
e.printStackTrace();
} catch (Exception e){
e.printStackTrace();
}
}
/**
* 添加数据
* @param map
* @return
*/
public String add( HashMap map )
{
ArrayList fields = new ArrayList();
ArrayList values = new ArrayList();
getFieldValueList(map , fields , values , true);
String field = StringUtil.join(",",fields);
String value = StringUtil.join("," , values);
String sql = "INSERT INTO "+mName+"("+field+") VALUES("+value+")";
int insertID = executeInsert(sql);
return insertID == -1 ? "" : String.valueOf(insertID);
}
/**
* 更新数据
* @param map
* @return
*/
public boolean save(HashMap map)
{
ArrayList fields = new ArrayList();
ArrayList values = new ArrayList();
getFieldValueList(map , fields , values , false);
ArrayList key2val = new ArrayList();
for(int i=0;i<fields.size();i++){
String field = (String)fields.get(i);
String value = (String)values.get(i);
key2val.add(field+"="+value);
}
ArrayList where = getOptionArrayList("where");
if(where.size() == 0 && map.containsKey(pk)){
this.where(pk , (String) map.get(pk));
}
if(where.size() == 0){
return false;
}
String sql = "UPDATE "+mName+" SET "+StringUtil.join("," , key2val)+" " + parseWhere(where);
executeInsert(sql);
return true;
}
/**
* 执行插入语句
* @param sql
* @return
*/
public int executeInsert(String sql)
{
try {
Connection conn = this.getConn();
Statement rs = conn.createStatement();
System.out.println(sql);
rs.executeUpdate(sql , Statement.RETURN_GENERATED_KEYS);
ResultSet rsKey = rs.getGeneratedKeys();
rsKey.next();
int id = rsKey.getInt(1);
return id;
}catch (SQLException e)
{
int code = e.getErrorCode();
String message = e.getMessage();
System.err.println("SQL execute Error");
System.err.println("code:"+code);
System.err.println("Message:"+message);
//e.printStackTrace();
}
return -1;
}
/**
* 执行更新语句
* @param sql
* @return
*/
public int executeUpdate(String sql)
{
try {
Connection conn = this.getConn();
Statement rs = conn.createStatement();
System.out.println(sql);
int id = rs.executeUpdate(sql , Statement.RETURN_GENERATED_KEYS);
return id;
}catch (SQLException e)
{
int code = e.getErrorCode();
String message = e.getMessage();
System.err.println("SQL execute Error");
System.err.println("code:"+code);
System.err.println("Message:"+message);
//e.printStackTrace();
}
return -1;
}
/**
* 快速构建Query
* @param name
* @return
*/
public static Query make(String name)
{
Query query = new Query();
query.setName(name);
return query;
}
/**
* 获取一页数据，并生成分页代码
* @param pagesize
* @return
*/
public Collect page( int pagesize )
{
Query c = new Query(getName());
c.mOption.putAll(mOption);
// 总长度
long count = c.count();
Collect result = new Collect( count , pagesize);
this.limit(result.firstRow , result.listRows);
builder.setPage(true);
ArrayList list = select();
builder.setPage(false);
result.addAll(list);
return result;
}
/**
* 解析条件
* @return
*/
protected String parseWhere()
{
if(!mOption.containsKey("where")){
return "";
}
return parseWhere(getOptionArrayList("where"));
}
/**
* 获取当前option
* @return
*/
public HashMap getOption() {
return mOption;
}
/**
* 解析条件
* @param whereList
* @return
*/
private String parseWhere(ArrayList whereList)
{
StringBuffer buffer = new StringBuffer();
for(int i=0;i<whereList.size();i++)
{
HashMap map = (HashMap) whereList.get(0);
if(i!=0){
// 每一个的连接符
buffer.append(" ");
buffer.append(map.get("connect"));
buffer.append(" ");
}
String key = (String) map.get("name");
String exp = (String) map.get("exp");
Object val = map.get("value");
if(-1 != key.indexOf("|")){
String[] keys = key.split("|");
buffer.append("(");
for(int j=0;j<keys.length;j++){
if(j!=0){
buffer.append(" OR ");
}
parseWhereItem(buffer , keys[j] , exp , val);
}
buffer.append(")");
}else{
parseWhereItem(buffer , key , exp , val);
}
}
if(buffer.length() > 0){
buffer.insert(0 , " where ");
}
return buffer.toString();
}
/**
* 根据当前条件，获取一列的数据
* @param field
* @return
*/
public List<String> getCol(String field)
{
List<String> result = new ArrayList();
// 取某一列
List<HashMap> list= select();
for (HashMap map:list){
result.add(map.get(field).toString());
}
return result;
}
/**
* 根据当前条件获取列数据,健对值的关系
* @param field
* @param key
* @return
*/
public Map<String ,String> getColkey(String field , String key)
{
Map result = new LinkedHashMap();
List<HashMap> list= select();
for (HashMap map:list){
result.put(map.get(key).toString(),map.get(field).toString());
}
return result;
}
/**
* 格式化字符串
* @param val
* @return
*/
private String formatString( String val)
{
return "'"+val.replace("'" , "\\'")+"'";
}
/**
* 解析where 条件子语句
* @param buffer
* @param key
* @param exp
* @param val
*/
private void parseWhereItem(StringBuffer buffer , String key , String exp , Object val)
{
List<String> exps = Arrays.asList("eq,neq,lt,elt,gt,egt".split(","));
int index = exps.indexOf(key);
String[] exps2 = "=,!=,<,<=,>,=>".split(",");
if(index != -1){
exp = exps2[index];
}
exp = exp.toLowerCase().trim();
if(exp.equals("in") || exp.equals("not in")){
ArrayList inArrayList = new ArrayList();
if(val instanceof String || val instanceof String[]){
String[] inList = val instanceof String ? ((String)val).split(",") : (String[]) val;
for (int i=0;i<inList.length;i++){
inArrayList.add(formatString(inList[i]));
}
}else if(val instanceof List){
for (int i=0;i<((List) val).size();i++)
{
inArrayList.add(formatString((String)((List) val).get(i)));
}
}else if(val instanceof int[]){
for (int i=0;i<((int[]) val).length;i++)
{
inArrayList.add(((int[]) val)[i]);
}
}else if(val instanceof float[]){
for (int i=0;i<((float[]) val).length;i++)
{
inArrayList.add(((float[]) val)[i]);
}
}else if(val instanceof double[]){
for (int i=0;i<((double[]) val).length;i++)
{
inArrayList.add(((double[]) val)[i]);
}
}else if(val instanceof long[]){
for (int i=0;i<((long[]) val).length;i++)
{
inArrayList.add(((long[]) val)[i]);
}
}
buffer.append(" ");
buffer.append(key);
buffer.append(" "+exp+"("+StringUtil.join("," , inArrayList)+") ");
}else{
buffer.append(" "+key);
buffer.append(" "+exp+" ");
buffer.append(formatString((String) val));
buffer.append(" ");
}
}
}
五，相关作品展示
基于Java开发、Python开发、PHP开发、C#开发等相关语言开发的实战项目
基于Nodejs、Vue等前端技术开发的前端实战项目
基于微信小程序和安卓APP应用开发的相关作品
基于51单片机等嵌入式物联网开发应用
基于各类算法实现的AI智能应用
基于大数据实现的各类数据管理和推荐系统
