在之前已经写过了jdbc的工具类，不过最近学习了新的方法，所以在这里重新写一遍，为后面的javaEE做铺垫；
首先我们要了解javaEE项目中，文件构成，新建一个javaEE项目，在项目中，有一个web文件夹，在web文件夹下有WEB-INF文件夹，我们的web.xml文件放在这个文件夹下，同时我们要新建两个文件夹，一个是classes文件夹，一个lib文件夹；
classes文件夹：我们做出来的程序，都是先编译成class文件，然后再jvm中运行class文件，所以运行时，并不需要java‘文件，因此要把编译好的class文件放在classes文件夹下，然后直接将web文件夹放在tomcat的webapps文件夹下就可以运行了。
这里写一下怎样将class文件放入classes文件夹：
我们先建四个包：
然后以建一个student表：
我们一这个表为基础，来模拟一次业务；
首先在entity中创建student表的实例化对象类Student：
package com.zs.entity;
/**
* 创建实例化是对象类Student
* 生成get和set方法，
* 空参及带参构造方法
* tostring方法*/
public class Student {
// 1定义成员变量
private int id;
private String sname;
private int age; public Student() {
super();
} public Student(int id, String sname, int age) {
this.id = id;
this.sname = sname;
this.age = age;
} public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getSname() {
return sname;
} public void setSname(String sname) {
this.sname = sname;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} @Override
public String toString() {
return "Student{" +
"id=" + id +
", sname='" + sname + '\'' +
", age=" + age +
'}';
}
}
然后我们在util包创建jdbc的工具类：
package com.zs.util; import com.alibaba.druid.pool.DruidDataSourceFactory; import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*; /**
* 1.导jar包，需要用到druid-1.0.9.jar，
* mysql-connector-java-5.1.45-bin.jar，
* servlet-api.jar
* 需要用到阿里的连接池，所以需要配置文件，配置文件放在src文件夹下，配置文件的内容之前有介绍
*/ public class DBUtils {
private static DataSource ds;
// 1.创建静态代码块读druid.properites配置文件,创建链接池
static {
Properties p = new Properties();
InputStream in = DBUtils.class.getClassLoader().getResourceAsStream("druid.properties");
try {
p.load(in);
ds = DruidDataSourceFactory.createDataSource(p);
} catch (Exception e) {
e.printStackTrace();
}
} // 2.创建获得连接对象的静态方法
public static Connection getConnection() throws SQLException {
return ds.getConnection();
} // 3.创建增删改的方法，并返回布尔类型,使用可变参数来传递占位符的值
public static boolean executeUpdate(String sql,Object... args){
Connection conn = null;
PreparedStatement ps = null;
try {
conn= getConnection();
ps = conn.prepareStatement(sql);
// 通过for循环来给占位符赋值
for (int i = 0; i < args.length; i++) {
ps.setObject(i+1,args[i]);
}
// 执行sql语句
int i = ps.executeUpdate();
return i>0;
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(conn,ps);
}
return false;
} // 创建查询的方法，并返回list集合
public static List<Map<String, Object>> executeQuery(String sql, Object... args) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn=getConnection();
ps = conn.prepareStatement(sql);
// 遍历可变数组传递占位符值
for (int i = 0; i < args.length; i++) {
ps.setObject(i+1,args[i]);
}
rs = ps.executeQuery();
List<Map<String,Object>> list=new ArrayList<>();
while (rs.next()) {
Map<String, Object> map = new LinkedHashMap<>();
/**这里可能会有问题，为什么是String，Object类型，因为我们通过rs.next只能获得一行结果，这一行结果，我们如果直接存入集合中的的化就是一个一个的值
* 我们无法识别哪儿个值是那儿一列的，所以用想到用map集合来装结果，key为列名，所以用String，因为一行中有多种数据类型，所以用obj来保存，用linkedHashMap
* 是因为map集合出来的结果是无序的，所以用linkedHashMap是有序的*/
// rs.getMetaData().getColumnCount();方法获得当前结果集的列数
for (int i = 0; i <rs.getMetaData().getColumnCount(); i++) {
// 通过列的索引获得列名，i+1是因为没有第0列，从第一列开始
String key = rs.getMetaData().getColumnLabel(i + 1);
// 通过键名来获得值
Object value = rs.getObject(key);
map.put(key, value);
}
list.add(map);
}
return list;
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(conn,ps,rs);
}
return null;
}
// 创建关闭流的方法
private static void close(Connection conn) {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
// 重载
private static void close(Connection conn, PreparedStatement ps) {
if (ps != null) {
try {
ps.close();
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(conn);
}
}
}
// 重载
private static void close(Connection conn, PreparedStatement ps, ResultSet rs) {
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}finally {
close(conn,ps);
}
}
}
}
然后我们写dao层的类：
package com.zs.dao; import com.zs.entity.Student; import java.util.List;
import java.util.Map; /**我们首先在dao层下面创建接口，因为我们需要一个多态的特征，所以在接口中写抽象方法，方便后期的修改和维护
* 为什么要用多态，为了程序解耦，接触程序的耦合性，在创建后期修改时，如果我们要修改某一个方法，那就看可能会导致其他的方法不能运行，
* 程序之间的联系就是耦合性，就像藕断丝连，越是复杂的程序，之间的联系就越多，而多态就是为了解耦*/
public interface IStudentDAO {
/**
* 在这里我们传递的参数为Student 对象
* 为什么要用student对象？
* 因为在实际开发中，我们的表中的数据可能有很多列，我们不能把所有的列都当参数来传递，那样太麻烦了，而且不方便后期的修改和维护和，
* 比如说，我们突然要删除一列，那么我们就要找到所有于该方法有关的方法，删除参数列表中相应的参数，这样太麻烦了，传递对象，我们通过get方法来获得参数*/
boolean add(Student s);
boolean upd(Student s);
boolean del(int id);
List<Map<String,Object>> getStudentById(int id);
List<Map<String,Object>> getAllStudent(); }
package com.zs.dao.impl;
/**
* 在创建完接口后，我们在dao层的下面新建一个impl文件夹，用来存放接口的实现类*/
import com.zs.dao.IStudentDAO;
import com.zs.entity.Student;
import com.zs.util.DBUtils; import java.util.List;
import java.util.Map; public class StudentImpl implements IStudentDAO {
@Override
public boolean add(Student s) {
String sql="insert into student(sname,age) value (?,?)";
// 通过get方法来传递占位符的值
return DBUtils.executeUpdate(sql, s.getSname(), s.getAge());
} @Override
public boolean upd(Student s) {
String sql = "update student set sname=? ,age=? where id=?";
return DBUtils.executeUpdate(sql, s.getSname(), s.getAge(), s.getId());
} @Override
public boolean del(int id) {
String sql = "delete from student where id=?";
return DBUtils.executeUpdate(sql, id);
} @Override
public List<Map<String, Object>> getStudentById(int id) {
String sql = "select * from student where id=?";
return DBUtils.executeQuery(sql, id);
} @Override
public List<Map<String, Object>> getAllStudent() {
String sql = "select * from student";
return DBUtils.executeQuery(sql);
}
}
然后我们在servlet包中建测试类来测试工具类：
package com.zs.servlet; import com.zs.dao.IStudentDAO;
import com.zs.dao.impl.StudentImpl;
import com.zs.entity.Student;
import com.zs.util.DBUtils;
import org.junit.Test; import java.util.List;
import java.util.Map; public class StudentServlet {
IStudentDAO is=new StudentImpl();
@Test
public void add(){
Student stu = new Student(1, "张三", 20);
// 这里这个 1 可能会有疑问，可以看一下dao层，我们插入语句中并没有用导id;写1是为了使用带参构造
boolean b = is.add(stu);
if (b) {
System.out.println("插入成功");
} else {
System.out.println("插入失败");
}
}
@Test
public void upd(){
Student stu = new Student(1, "张三", 20);
boolean b = is.upd(stu);
if (b) {
System.out.println("修改成功");
} else {
System.out.println("修改失败");
}
}
@Test
public void del(){
boolean b = is.del(1);
if (b) {
System.out.println("删除成功");
} else {
System.out.println("删除失败");
}
}
@Test
public void sel(){
List<Map<String, Object>> list = is.getStudentById(2);
if (list.size() > 0) {
System.out.println(list);
} else {
System.out.println("该学生不存在");
}
}
@Test
public void selAll(){
List<Map<String, Object>> list = is.getAllStudent();
System.out.println(list);
}
}
上面完成后，我们下面写一个页面，完成简单的表单验证，点击提交后，数据提交到后台，然后后台调用dao层，数据对比：
首先创建一个login表：
然后我们在dao层中创建ilogin接口：
package com.zs.dao;
public interface ILoginDAO {
boolean login(String username, String password);
}
然后在impl文件夹中创建实现类：
package com.zs.dao.impl; import com.zs.dao.ILoginDAO;
import com.zs.util.DBUtils; import java.util.List;
import java.util.Map; public class LoginImpl implements ILoginDAO { @Override
public boolean login(String username, String password) {
String sql = "select * from login where sname=? and pwd=?";
List<Map<String, Object>> list = DBUtils.executeQuery(sql, username, password);
return list.size()>0;
}
}
然后我们写一个简单的html页面，html页面放在web文件夹下；
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>登录界面</title>
</head>
<body>
<form action="/zs/login" method="post">
<input type="text" name="username" placeholder="请输入用户名"><br>
<input type="password" name="password" placeholder="请输入密码"><br>
<input type="submit" value="登录">
</form>
</body>
</html>
下面写登陆的后台Servlet：
package com.zs.servlet; import com.zs.dao.ILoginDAO;
import com.zs.dao.impl.LoginImpl; 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 java.io.IOException; @WebServlet(name = "LoginServlet")
public class LoginServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 将请求的数据转为utf-8的格式，没有这句话的话，会出现登录中文用户名失败
request.setCharacterEncoding("utf-8");
String username = request.getParameter("username");
String password = request.getParameter("password");
ILoginDAO lo=new LoginImpl();
boolean b = lo.login(username, password);
if (b) {
System.out.println("登录成功");
// 成功跳转页面方法与下面一样，这里没有写可以跳转的页面
} else {
System.out.println("登陆失败");
// 失败返回登录页面
response.sendRedirect("Login.html");
}
} protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request,response);
}
}
配置tomcat的方法再之前写过，然后直接启动tomcat就好了