概述
这次是做的一个简单的前端和数据库结合实现的一个注册功能.
DAO类
package com.softeem.dao;
import com.softeem.entity.User;
import com.softeem.db.DBUtils;
import sun.security.util.Password;
import java.sql.Connection;
import java.util.List;
/**
* @Author liqiuyang 2020/8/21 15:40
*/
public class RegDAO {
private Connection conn;
public RegDAO() {
}
public RegDAO(Connection conn) {
this.conn = conn;
}
public boolean insert(User u){
String sql = "insert into tbuser (name,password,age) values(?,?,?)";
return DBUtils.exeUpdate(sql,u.getName(),u.getPassword(),u.getAge());
}
public User selectUser(String name,String password){
String sql = "select * from tbuser where name=? and password=?";
return DBUtils.queryOne(User.class,sql,name,password);
}
public List<User> selectlist(){
return DBUtils.queryList(User.class,"select * from tbuser");
}
public boolean delete(int id){
String sql = "delete from tbuser where id=?";
return DBUtils.exeUpdate(sql,id);
}
public boolean update(User u){
String sql = "update tbuser set password=? where id=?";
return DBUtils.exeUpdate(conn,sql,u.getPassword(),u.getId());
}
}
工具类
package com.softeem.db;
import com.alibaba.druid.pool.DruidDataSource;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;
/**
* 数据库工具类v2.0 将访问数据的公共代码抽取： 1.加载驱动 2.连接获取 6.关闭资源
*
* @author Magicbookpro
*
*/
public class DBUtils {
/** 驱动类路径 */
private static String DRIVER_CLASS;
/** url地址 */
private static String URL;
/** 数据库服务器登录用户名 */
private static String USER;
/** 数据库服务器登录密码 */
private static String PASSWORD;
/**最大活动链接数*/
private static int MAX_ACTIVE;
/**最长等待连接获取的时间*/
private static long MAX_WAIT;
/**初始链接数*/
private static int INIT_SIZE;
/**声明连接池的引用*/
private static DruidDataSource ds;
static {
try {
//读取属性文件后去连接数据库相关的字符串
InputStream is = DBUtils.class.getResourceAsStream("/jdbc.properties");
//创建属性对象
Properties p = new Properties();
//加载包含属性信息的输入流
p.load(is);
//根据属性名获取属性值
DRIVER_CLASS = p.getProperty("driver");
URL = p.getProperty("url");
USER = p.getProperty("user");
PASSWORD = p.getProperty("password");
//获取连接池相关配置
MAX_ACTIVE = Integer.parseInt(p.getProperty("pool.maxActive"));
MAX_WAIT = Long.parseLong(p.getProperty("pool.maxWait"));
INIT_SIZE = Integer.parseInt(p.getProperty("pool.initSize"));
//初始化连接池
init();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 初始化连接池
*/
public static void init() {
ds = new DruidDataSource();
ds.setDriverClassName(DRIVER_CLASS);
ds.setUrl(URL);
ds.setUsername(USER);
ds.setPassword(PASSWORD);
ds.setMaxActive(MAX_ACTIVE);
ds.setInitialSize(INIT_SIZE);
ds.setMaxWait(MAX_WAIT);
}
/**
* 2.获取数据库连接对象
*
* @return
*/
public static synchronized Connection getConn() {
try {
//当连接池被关闭或者为null重新初始化
if(ds == null || ds.isClosed()) {
init();
}
//从连接池中获取一个连接并返回
return ds.getConnection();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/**
* 关闭资源
*
* @param rs
* @param stat
* @param conn
*/
public static void close(ResultSet rs, Statement stat, Connection conn) {
try {
if (rs != null)
rs.close();
if (stat != null)
stat.close();
if (conn != null)
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 封装通用的更新操作：INSERT UPDATE DELETE
*
* @param sql
* @param params
* @return
*/
public static boolean exeUpdate(Connection conn,String sql, Object... params) {
PreparedStatement ps = null;
try {
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
return ps.executeUpdate() > 0;
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(null, ps, null);
}
return false;
}
/**
*
* @param sql
* @param params
* @return
*/
public static boolean exeUpdate(String sql, Object... params) {
PreparedStatement ps = null;
Connection conn = getConn();
try {
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i + 1, params[i]);
}
}
return ps.executeUpdate() > 0;
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(null,ps,conn);
}
return false;
}
/**
* 封装通用查询单条数据的方法
*
* @param <T>
* @param t
* @param sql
* @param params
* @return
*/
public static <T> T queryOne(Class<T> t, String sql, Object... params) {
// 获取查询到的数据集合
List<Map<String, Object>> list = queryMaps(sql, params);
if (list.size() > 0) {
// 获取一个Map对象
Map<String, Object> map = list.get(0);
// 将map集合转换为JavaBean并返回
return mapToBean(map, t);
}
return null;
}
/**
* 封装通用查询多条数据的方法
*
* @param <T>
* @param t
* @param sql
* @param params
* @return
*/
public static <T> List<T> queryList(Class<T> t, String sql, Object... params) {
List<T> list = new ArrayList<>();
// 获取所有查询到的数据
List<Map<String, Object>> maps = queryMaps(sql, params);
// 遍历集合中每一条数据(map)
maps.forEach(m -> {
// 将map转换为JavaBean
T obj = mapToBean(m, t);
// 将JavaBean装入list
list.add(obj);
});
return list;
}
/**
* 将Map集合转换为一个确定的类型
*
* @param <T>
* @param map
* @param t
* @return
*/
private static <T> T mapToBean(Map<String, Object> map, Class<T> t) {
T obj = null;
try {
// 根据提供的类型创建对应类型的Object
obj = t.newInstance();
// 获取Class中的所有Field
Field[] fields = t.getDeclaredFields();
// 遍历获取每一个属性对象
for (Field field : fields) {
// 获取属性名
String fname = field.getName();
// 获取属性值
Object value = map.get(fname);
if (value != null) {
// 设置属性对象的可访问性
field.setAccessible(true);
// 将从map中获取的值设置给属性
field.set(obj, value);
}
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return obj;
}
/**
* 执行相关查询之后并将结果返回为List<Map<String,Object>>集合
*
* @param sql
* @param params
* @return
*/
public static List<Map<String, Object>> queryMaps(String sql, Object... params) {
// 声明动态数据用于存储每一个查询到的Map对象
List<Map<String, Object>> list = new ArrayList<>();
// 获取连接
Connection conn = getConn();
PreparedStatement ps = null;
ResultSet rs = null;
try {
// 获取与预处理sql命令的对象
ps = conn.prepareStatement(sql);
if (params != null) {
for (int i = 0; i < params.length; i++) {
// 对指定位置的占位符填充值（预处理）
ps.setObject(i + 1, params[i]);
}
}
// 执行查询获取结果集
rs = ps.executeQuery();
// 获取结果集的元数据对象ResultSetMetaData
ResultSetMetaData rsmd = rs.getMetaData();
// 获取总查询列数
int columCount = rsmd.getColumnCount();
// 遍历结果集
while (rs.next()) {
// 声明Map集合存储每一条数据(临时缓存)
Map<String, Object> map = new HashMap<String, Object>();
// 遍历获取每一列的信息
for (int i = 1; i <= columCount; i++) {
// 获取列名称(作为Map集合的键)
String key = rsmd.getColumnName(i);
// 获取列标签(利用标签取值)
String label = rsmd.getColumnLabel(i);
// 获取列值(作为map集合的值)
Object value = rs.getObject(label);
if (value != null) {
// 将获取到的每一列的列名与列值存储到map
map.put(key, value);
}
}
// 将map集合装入list
list.add(map);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
close(rs, ps, conn);
}
return list;
}
/**
* 根据提供的查询语句以及查询参数，返回符合条件的数目
* @param sql
* @param params
* @return
*/
public static int queryCount(String sql,Object...params) {
Connection conn = getConn();
PreparedStatement ps =null;
ResultSet rs = null;
try {
ps = conn.prepareStatement(sql);
if(params != null) {
for (int i = 0; i < params.length; i++) {
ps.setObject(i+1,params[i]);
}
}
rs = ps.executeQuery();
if(rs.next()) {
return rs.getInt(1);
}
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(rs,ps,conn);
}
return 0;
}
}
实体类
package com.softeem.entity;
/**
* @Author liqiuyang 2020/8/21 15:42
*/
public class User {
private int id;
private String name;
private String password;
private int age;
public User() {
}
public User(int id, String name, String password, int age) {
this.id = id;
this.name = name;
this.password = password;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "java{" +
", name='" + name + ''' +
", password='" + password + ''' +
", age=" + age +
'}';
}
}
package com.softeem.servlets;
import com.softeem.dao.RegDAO;
import com.softeem.entity.User;
import org.apache.commons.beanutils.BeanUtils;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
@WebServlet("/reg")
public class RegisServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws ServletException, IOException {
doGet(request,response);
}
protected void doGet(HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws ServletException, IOException {
Map<String,String[]> map = request.getParameterMap();
User user = new User();
try {
BeanUtils.populate(user,map);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
RegDAO rd = new RegDAO();
boolean r = rd.insert(user);
//设置响应头中的内容类型,同时设置编码
response.setContentType("text/html;charset=utf-8");
PrintWriter out = response.getWriter();
if (r){
out.println("<h1 style='color:#0f0'>注册成功!!!</h1>");
}else{
response.getWriter().write("false");
}
}
}
注册页面html文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>注册页面</h1>
<form action="reg">
username:<input type="text" name="name"><br>
password:<input type="possword" name="password"><br>
user age:<input type="text" name="age"><br>
<button type="submit">注册</button>
</form>
</body>
</html>
配置文件
# jdbc connection
driver=com.mysql.jdbc.Driver
url=jdbc:mysql:///mydb3
user=root
password=123456
# connection pool settings
pool.maxActive=10
pool.initSize=5
pool.maxWait=30000
数据库
最后
以上就是细腻宝贝为你收集整理的前后端结合注册功能的全部内容，希望文章能够帮你解决前后端结合注册功能所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复