前言：避免遗忘，附上所有代码
1、效果图
2、该JaveWeb项目的目录结构
util包下都是对jdbc的一些封装，与本篇博文主旨关系不大，感兴趣可移步：
https://blog.csdn.net/Carl_changxin/article/details/82112563
3、userList.html的代码:
页面中的css和js下载地址：http://www.jeasyui.net/download/
页面中的难点解释：
（1）url="getUserList" method="post" : 这里表示向后台发出servlet请求，要求返回json数据
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="stylesheet" type="text/css" href="css/themes/default/easyui.css">
<link rel="stylesheet" type="text/css" href="css/themes/icon.css">
<link rel="stylesheet" type="text/css" href="css/demo.css">
<script type="text/javascript" src="js/jquery.min.js"></script>
<script type="text/javascript" src="js/jquery.easyui.min.js"></script>
</head>
<body>
<!--url的作用是提交一个请求，要求返回json数据，rows参数一定要有,在getUserList的servlet中有对此说明 -->
<table id="dg" title="My Users" class="easyui-datagrid" style="width:650px;height:250px"
url="getUserList"
method="post"
toolbar="#toolbar"
rownumbers="true" fitColumns="true" singleSelect="true">
<thead>
<tr>
<!-- 将id列隐藏起来;更新或删除某条数据都需要用到id -->
<th field="id" hidden='true'></th>
<th field="firstname" width="50">First Name</th>
<th field="lastname" width="50">Last Name</th>
<th field="phone" width="50">Phone</th>
<th field="email" width="50">Email</th>
</tr>
</thead>
</table>
<!-- 下面是我们页面上的三个编辑按钮，我们要将3个方法实现出来 -->
<div id="toolbar">
<a href="#" class="easyui-linkbutton" iconCls="icon-add" plain="true" onclick="newUser()">New User</a>
<a href="#" class="easyui-linkbutton" iconCls="icon-edit" plain="true" onclick="editUser()">Edit User</a>
<a href="#" class="easyui-linkbutton" iconCls="icon-remove" plain="true" onclick="destroyUser()">Remove User</a>
</div>
<!-- 这是一个对话框，默认是关闭的；我们要做的就是在点击New User或Edit USer时，将属性closed="false" 这需要js来完成-->
<div id="dlg" class="easyui-dialog" style="width:400px;height:280px;padding:10px 20px"
closed="true" buttons="#dlg-buttons">
<div class="ftitle">User Information</div>
<form id="fm">
<div class="fitem">
<input name="id" class="easyui-validatebox" hidden="true">
</div>
<div class="fitem">
<label>First Name:</label>
<input name="firstname" class="easyui-validatebox" required="true">
</div>
<div class="fitem">
<label>Last Name:</label>
<input name="lastname" class="easyui-validatebox" required="true">
</div>
<div class="fitem">
<label>Phone:</label>
<input name="phone">
</div>
<div class="fitem">
<label>Email:</label>
<input name="email" class="easyui-validatebox" validType="email">
</div>
</form>
</div>
<!-- 下面的保存和取消按钮，已经和上面的对话框绑定了 ；记得实现saceUser()方法-->
<div id="dlg-buttons">
<a href="#" class="easyui-linkbutton" iconCls="icon-ok" onclick="saveUser()">Save</a>
<a href="#" class="easyui-linkbutton" iconCls="icon-cancel" onclick="javascript:$('#dlg').dialog('close')">Cancel</a>
</div>
</body>
</html>页面的js代码
SaveUser方法的解释：
（1）点击New User 或 选择某条记录后点击Edit User 都会弹出对话框id=dlg
（2）对话框中有Save按钮，在点击Save之前要判断当前是新增还是更新，再做相应的后台处理
<script type="text/javascript">
/* 点击New User会打开对话框,清空form表单内容 */
function newUser(){
$('#dlg').dialog('open').dialog('setTitle','New User');
$('#fm').form('clear');
}
/* 编辑/更新数据 */
function editUser(){
/* 数据网格（datagrid）组件包含两种方法来检索选中行数据：
getSelected：取得第一个选中行数据，如果没有选中行，则返回 null，否则返回记录。
getSelections：取得所有选中行数据，返回元素记录的数组数据。 */
var row = $('#dg').datagrid('getSelected');
if (row){
$('#dlg').dialog('open').dialog('setTitle','Edit User');
//将对话框中的文本框用当前选中行数据填满，待修改
$('#fm').form('load',row);
}else{
alert("请先选择一条数据");
}
}
/* 保存一条新数据，先获取各个输入框中的值，再通过ajax传输到后台进行保存 */
function saveUser(){
var id = $("[name='id']").val();
var firstname = $("[name='firstname']").val();
var lastname = $("[name='lastname']").val();
var phone = $("[name='phone']").val();
var email = $("[name='email']").val();
/* 要判断这里是添加新数据还是更新数据，因为执行的sql语句不同，所以要求后台不一样 */
//获取对话框的title属性，根据这个来判断
var title = $('#dlg').panel('options').title
if(title=='New User'){
$.ajax({
url:"saveUser",
type:"post",
data:{firstname:firstname,lastname:lastname,phone:phone,email:email},
dataType:"json",
success:function(result){
if(result.code ==200){
//alert("保存成功")
//保存成功，就刷新列表数据；两种方法
/* window.location.href = "userList.html"; */
$('#dlg').dialog('close');
$('#dg').datagrid('reload');
}else{
$.messager.show({
title: 'Error',
msg: result.errorMsg
});
}
}
})
}else{
$.ajax({
url:"updateUser",
type:"post",
data:{id:id,firstname:firstname,lastname:lastname,phone:phone,email:email},
dataType:"json",
success:function(result){
if(result.code ==200){
//alert("保存成功")
//保存成功，就刷新列表数据；两种方法
/*window.location.href = "userList.html"; */
$('#dlg').dialog('close');
$('#dg').datagrid('reload');
}else{
$.messager.show({
title: 'Error',
msg: result.errorMsg
});
}
}
})
}
}
function destroyUser(){
var row = $('#dg').datagrid('getSelected');
if (row){
$.messager.confirm('Confirm','Are you sure you want to destroy this user?',function(r){
if (r){
//下面是ajax的简化写法
/* $.post()格式 $.post(url,data,success(data, textStatus, jqXHR),dataType) */
//可查看：https://blog.csdn.net/vsiryxm/article/details/46391765
$.post('deleteUser',{id:row.id},function(result){
if (result.code==200){
$('#dg').datagrid('reload'); // reload the user data
} else {
$.messager.show({ // show error message
title: 'Error',
msg: result.errorMsg
});
}
},'json');
}
});
}else{
alert("请先选择一条数据");
}
}
</script>4、servlet包下的所有类
注意：我都是用注解的方式配置本应在web.xml中配置的servlet-mapping
GetUserListServlet.java:
package servlet;
import java.io.IOException;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSONObject;
import entity.User;
@WebServlet(name = "getUserListServlet", urlPatterns = { "/getUserList" })
public class GetUserListServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
User user = new User();
//在这个findUser方法中rows是key（必须是rows,才能被easyui识别），查出来的user数据是一个list作为值
Map<String,Object> map = user.findUser();
response.setCharacterEncoding("utf-8");
response.getWriter().print(JSONObject.toJSON(map));
}
}
SaveUserServlet.java:
package servlet;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSONObject;
import entity.User;
import util.GetParams;
/**
* Servlet implementation class AddBlogServlet
*/
@WebServlet(name = "saveUserServlet", urlPatterns = { "/saveUser" })
public class SaveUserServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//获得参数，构造对象，接收参数，保存对象到数据库
Map<String,String[]> params = request.getParameterMap();
@SuppressWarnings("unchecked")
User user = (User) GetParams.getInstance().formatBean(params, User.class);
int res = user.save();
Map<String,Object> map = new HashMap<String,Object>();
//save方法的返回值是int，成功则设置个标志code=200
if(res == 1) {
map.put("code", 200);
}else{
map.put("code", 500);
}
response.getWriter().print(JSONObject.toJSON(map));
}
}
UpdateUserServlet.java:
package servlet;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSONObject;
import entity.User;
import util.GetParams;
/**
* Servlet implementation class UpdateBlogServlet
*/
@WebServlet(name = "updateUserServlet", urlPatterns = { "/updateUser" })
public class UpdateUserServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//获得参数，构造对象，接收参数，保存对象到数据库
Map<String,String[]> params = request.getParameterMap();
User user = (User) GetParams.getInstance().formatBean(params, User.class);
int res = user.alertById();
Map<String,Object> map = new HashMap<String,Object>();
if(res == 1) {
map.put("code", 200);
}else{
map.put("code", 500);
}
response.getWriter().print(JSONObject.toJSON(map));
}
}
DeleteUserServlet.java:
package servlet;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.alibaba.fastjson.JSONObject;
import entity.User;
@WebServlet(name = "deleteUserServlet", urlPatterns = { "/deleteUser" })
public class DeleteUserServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String id = request.getParameter("id");
User user = new User();
user.setId(Integer.valueOf(id));
int res = user.remove();
Map<String,Object> map = new HashMap<String,Object>();
if(res == 1) {
map.put("code", 200);
}else{
map.put("code", 500);
}
response.getWriter().print(JSONObject.toJSON(map));
}
}
5、entity包
User.java
package entity;
import util.BaseDao;
public class User extends BaseDao<User>{
public User() {
super("t_user");
}
private Integer id;
private String firstname;
private String lastname;
private String phone;
private String email;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
数据库：
6、util包
BaseDao.java
package util;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*1、实体类去继承该类，该类会提供增删改查的方法，让实体对象去调用
*2、 实体类对应数据库中的一张表，一个实体对象对应表中的一条数据
*3、该类中提供的增删改查方法，只是拼接了sql语句，再交给JDBC去做
*4、sql语句的可变部分可以看做是对象的属性和属性值，因此可以通过反射去获取实体对象的属性和属性值，拼接sql语句
* @param <T>
*/
public class BaseDao<T> {
private JDBC jdbc = JDBC.getInstance();
@SuppressWarnings("rawtypes")
private Class cls = this.getClass();
private String tableName;
public BaseDao(String tableName){
this.tableName = tableName;
}
/**
* 保存对象到数据库
* insert into 表名(列名/属性名...) value (属性值);
* @return 影响的行数
*/
public int save(){
/**拼接插入语句*/
StringBuffer insertSql = new StringBuffer("insert into "+tableName+" (");
StringBuffer fieldsSql = new StringBuffer();
StringBuffer fieldsValSql = new StringBuffer();
Field[] fields = cls.getDeclaredFields();
try {
for(Field f : fields){
f.setAccessible(true);
//当属性名不是id并且属性值不为空时,把该属性当作插入条件之一
if(!"id".equals(f.getName()) && f.get(this) != null ){
fieldsSql.append("`"+f.getName()+"`"+",");
fieldsValSql.append("'"+f.get(this)+"'"+",");
}
}
} catch (Exception e) {
e.printStackTrace();
}
if(fieldsSql.length()!=0) {
fieldsSql.replace(fieldsSql.length()-1, fieldsSql.length(), "");
fieldsValSql.replace(fieldsValSql.length()-1, fieldsValSql.length(), "");
}
insertSql.append(fieldsSql+") value ("+fieldsValSql+");");
System.out.println(insertSql);
return jdbc.insert(insertSql.toString());
}
/**
* 根据当前对象的属性进行删除，以不为空的属性作为删除的过滤添加
* delete from tableName where 属性1名=属性1值 and 属性2名=属性2值 ...
* @return 影响的行数
*/
public int remove(){
StringBuffer deleteSql = new StringBuffer();
StringBuffer attrVal = new StringBuffer();
/**获得类中所有的属性*/
Field[] fields = cls.getDeclaredFields();
for(Field f : fields){
f.setAccessible(true);
try {
if(f.get(this) != null){
attrVal.append("`"+f.getName()+"`='"+f.get(this)+"' and ");
}
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
}
attrVal.replace(attrVal.length()-4, attrVal.length(), "");
deleteSql.append("delete from `"+tableName+"` where "+attrVal+";");
System.out.println(deleteSql);
return jdbc.delete(deleteSql.toString());
}
/**
* 修改对象对应数据库中的列
* //update t_user set name='',age='' where id=''
* @return 影响的行数
*/
public int alertById(){
StringBuffer updateSql = new StringBuffer();
StringBuffer attrVal = new StringBuffer();
Integer idVal = null;
/**获得类中所有的属性*/
Field[] fields = cls.getDeclaredFields();
for(Field f : fields){
f.setAccessible(true);
try {
if(!"id".equals(f.getName())){
if(f.get(this) != null){
attrVal.append("`"+f.getName()+"`='"+f.get(this)+"',");
}
}else{
if(f.get(this) == null){
System.out.println("id没有值");
}else{
idVal = (Integer) f.get(this);
}
}
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
}
attrVal.replace(attrVal.length()-1, attrVal.length(), "");
updateSql.append("update `"+tableName+"` set "+attrVal+" where "+"`id`='"+idVal+"';");
System.out.println(updateSql);
return jdbc.update(updateSql.toString());
}
/**
* 查找符合条件的数据
* select * from tableName where ...
* @return 查找到的结果，转化成对象
*/
public List<T> find(){
StringBuffer querySql = new StringBuffer("select * from "+tableName);
StringBuffer attrVal = new StringBuffer();
Field[] fields = cls.getDeclaredFields();
for(Field f : fields){
f.setAccessible(true);
try {
if(f.get(this) !=null){
attrVal.append("`"+f.getName()+"`='"+f.get(this)+"' and ");
}
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
}
if(attrVal.length() != 0){
attrVal.replace(attrVal.length()-4, attrVal.length(), "");
querySql.append(" where "+attrVal+";");
}else{
querySql.append(";");
}
System.out.println(querySql);
//查询出来的结果开始是结果集，然后转化成List<Map<String,Object>>集合，再转化成对象
List<Map<String,Object>> lists = jdbc.query(querySql.toString());
// System.out.println(lists.size());
//遍历lists集合
try {
List<T> list = new ArrayList<T>();//用来存放对象
for(Map<String,Object> m : lists){
@SuppressWarnings("unchecked")
T t = (T)cls.newInstance();
//遍历Map集合,一个Map集合对应一个对象
for( Map.Entry<String,Object> entry: m.entrySet() ){
//根据列名称，获取当前对象的对应该列的属性
Field f = cls.getDeclaredField(entry.getKey());
//设置对象的属性值
f.setAccessible(true);
f.set(t, entry.getValue());
}
list.add(t);
}
return list;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 封装分页
* @param page
* @param rows
* @return
*/
public Map<String,Object> find(Integer page,Integer rows){
//一个map集合用来存放查询出来的一条数据，按照<列名，列值>保存
Map<String,Object> map = new HashMap<String,Object>();
//T设置成Map<String,Object>就可以存放多条查询出来的数据
List<T> list = new ArrayList<T>();
//获得对象所有的属性（包括私有属性）
Field[] fields = cls.getDeclaredFields();
StringBuffer selectSqlBuf = new StringBuffer("select * from "+tableName+" where 1=1");
try {
for(Field f : fields) {
String proName = f.getName();//age
f.setAccessible(true);
Object value = f.get(this);//获得当前属性的值
if(value!=null) {
selectSqlBuf.append(" and "+proName+"='"+value+"'");
}
}
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
selectSqlBuf.append(" limit "+(page-1)*rows+","+rows+";");
System.out.println(selectSqlBuf);
List<Map<String,Object>> mapList = jdbc.query(selectSqlBuf.toString());
try {
for(Map<String,Object> m :mapList) {
//一个对象对应数据库中的一条数据，m对应当前的一条数据，即也对应一个对象
//通过反射实例化一个对象，去封装循环出来的每一条数据
T t = (T) cls.newInstance();
for (Map.Entry<String, Object> entry : m.entrySet()) {
String key = entry.getKey().toString();
Object value = entry.getValue();
Field f = cls.getDeclaredField(key);//根据属性名称，获取当前对象的属性
f.setAccessible(true);
f.set(t, value);
}
list.add(t);
}
} catch (InstantiationException | IllegalAccessException | NoSuchFieldException | SecurityException
| IllegalArgumentException e) {
e.printStackTrace();
}
//计算总共有多少页
Long total = Long.valueOf(jdbc.query("select count(1) as total from "+tableName).get(0).get("total")+"");
Long pages = (total+rows-1)/rows;
map.put("data", list);
map.put("page",page);
map.put("rows",rows);
map.put("pages", pages);
//map中保存了当前页面要显示的数据list,页码page,条数rows,总页数pages
return map;
}
public Map<String,Object> findUser(){
//一个map集合用来存放查询出来的一条数据，按照<列名，列值>保存
Map<String,Object> map = new HashMap<String,Object>();
//T设置成Map<String,Object>就可以存放多条查询出来的数据
List<T> list = new ArrayList<T>();
//获得对象所有的属性（包括私有属性）
Field[] fields = cls.getDeclaredFields();
StringBuffer selectSqlBuf = new StringBuffer("select * from "+tableName+" where 1=1");
try {
for(Field f : fields) {
String proName = f.getName();//age
f.setAccessible(true);
Object value = f.get(this);//获得当前属性的值
if(value!=null) {
selectSqlBuf.append(" and "+proName+"='"+value+"'");
}
}
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
System.out.println(selectSqlBuf);
List<Map<String,Object>> mapList = jdbc.query(selectSqlBuf.toString());
try {
for(Map<String,Object> m :mapList) {
//一个对象对应数据库中的一条数据，m对应当前的一条数据，即也对应一个对象
//通过反射实例化一个对象，去封装循环出来的每一条数据
T t = (T) cls.newInstance();
for (Map.Entry<String, Object> entry : m.entrySet()) {
String key = entry.getKey().toString();
Object value = entry.getValue();
Field f = cls.getDeclaredField(key);//根据属性名称，获取当前对象的属性
f.setAccessible(true);
f.set(t, value);
}
list.add(t);
}
} catch (InstantiationException | IllegalAccessException | NoSuchFieldException | SecurityException
| IllegalArgumentException e) {
e.printStackTrace();
}
map.put("rows", list);
return map;
}
}
JDBC.java
package util;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
/**
* 1、和数据库建立连接
* 2、处理DB_Dao传送过来的sql语句，包括增删改查
*/
public class JDBC {
//饿汉模式
private static JDBC jdbc = new JDBC();
private String driver;
private String url;
private String name;
private String password;
private Connection conn;
public static void main(String[] args) {
JDBC jdbc = new JDBC();
}
/**
* 单例模式，私有化构造方法
*/
private JDBC(){
readProperties();
}
//获得JDBC对象的公开方法
public static JDBC getInstance(){
return jdbc;
}
//读取配置文件
private void readProperties(){
try {
Properties p = new Properties();
InputStream is = JDBC.class.getResourceAsStream("mysql.properties");
p.load(is);
is.close();
driver = p.getProperty("driver");
url = p.getProperty("url");
name = p.getProperty("name");
password = p.getProperty("password");
} catch (IOException e) {
e.printStackTrace();
}
}
//连接数据库
private Connection conn(){
try {
Class.forName(driver);
return DriverManager.getConnection(url,name,password);
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
return null;
}
/**
* 增删改操作
* @return 返回受影响的行数
*/
private int DML(String sql,Object...paras){
PreparedStatement ps = null;
try {
conn = conn();
ps = conn.prepareStatement(sql);
/**
* 设置参数
*/
int i=1;
for(Object o : paras){
ps.setObject(i++, o);
}
return ps.executeUpdate();
} catch (SQLException e) {
e.printStackTrace();
}finally{
if(ps != null){
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return 0;
}
public int insert(String sql,Object...paras){
return DML(sql,paras);
}
public int update(String sql,Object...paras){
return DML(sql,paras);
}
public int delete(String sql,Object...paras){
return DML(sql,paras);
}
private List<Map<String,Object>> DQL(String sql,Object...paras){
List<Map<String,Object>> lists = new ArrayList<Map<String,Object>>();
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = conn();
ps = conn.prepareStatement(sql);
int i = 1;
for(Object o : paras){
ps.setObject(i++, o);
}
rs = ps.executeQuery();
//对结果集进行操作
ResultSetMetaData rsmd = rs.getMetaData();
int columnCount = rsmd.getColumnCount();
while(rs.next()){
Map<String,Object> map = new HashMap<String,Object>();
for(int j=1;j<=columnCount;j++){
map.put(rsmd.getColumnName(j), rs.getObject(j));
}
lists.add(map);
}
return lists;
} catch (SQLException e) {
e.printStackTrace();
}finally{
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(ps != null){
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
return null;
}
public List<Map<String,Object>> query(String sql,Object...paras){
return DQL(sql,paras);
}
}
GetParams.java:
package util;
import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.Map;
public class GetParams<T> {
private static GetParams param = new GetParams();
/**
* 私有化构造方法，实现单例模式
*/
private GetParams(){
};
public static GetParams getInstance() {
return param;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public T formatBean(Map<String,String[]> params,Class cls){
try {
//通过反射将传过来的值，赋值给对象的属性
Iterator iterator = params.keySet().iterator();
T t = (T) cls.newInstance();
while(iterator.hasNext()){
String key = iterator.next().toString();
Field field;
try {
field = cls.getDeclaredField(key);
String[] values = params.get(key);//取得当前参数的值
if(values!=null&&values.length!=0){
field.setAccessible(true);
String type = field.getType().getName();//取得当前的key所对应属性的类型
if("java.lang.String".equals(type)){
field.set(t, values[0]);
}else if("java.lang.Integer".equals(type)){
field.set(t, Integer.valueOf(values[0]));
}
}
} catch (Exception e) {
System.out.println(key+"这个属性在对象里没有");
}
}
return t;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
mysql.properties:
driver=com.mysql.jdbc.Driver
url=jdbc\:mysql\://localhost\:3306/easyui
name=root
password=1