目录
3.1使用prepareStatement来解决sql注入的问题。
3.2. 完成增删改查--使用PreparedStatement
1. java连接mysql数据库
步骤:
1.创建一个java工程。
2.在工程下创建一个目录lib---->放jar的。
3.把该jar进行解压--->一定要在程序中完成。
4.写程序。
public class Test01 {
public static void main(String[] args)throws Exception {
//1.加载驱动---理解为引用翻译
Class.forName("com.mysql.cj.jdbc.Driver");
//2.获取连接对象
// String url, 数据库的路径 mysql5.7以后
// 协议:数据的种类://ip:端口号/数据库名?serverTimezone=Asia/Shanghai
// jdbc:mysql://
// String user,账号
// String password 密码
String url="jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
String user="root";
String password="123456";
Connection connection= DriverManager.getConnection(url,user,password);
//3.获取执行sql语句的对象。
Statement statement=connection.createStatement();
//4.执行sql语句。增删改
String sql="delete from t_student where id=1";
statement.executeUpdate(sql);
}
}添加数据 ：
public class TestJdbc {
//测试添加功能---往数据库中添加
@Test
public void testInsert() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
String user="root";
String password="root"; //这里的密码要和你自己的对照
Connection connection = DriverManager.getConnection(url,user,password);
Statement statement = connection.createStatement();
String sql="insert into t_student values(null,'玉慧梦',16,'北京')";
statement.executeUpdate(sql);
}
@Test
public void testUpdate() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
String user="root";
String password="root"; //这里的密码要和你自己的对照
Connection connection = DriverManager.getConnection(url,user,password);
Statement statement = connection.createStatement();
String sql="update t_student set name='蜡笔小新',age=5,address='春日部' where id=2";
statement.executeUpdate(sql);
}
}2.查询数据库表中记录
@Test //理解为main函数。可以独立运行。
public void testQuery() throws Exception { //抛出异常只是为了操作方便。真正在开发时应该try--catch
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai", "root", "root");
Statement statement = conn.createStatement();
String sql = "select id,name,age,address from t_student";
//执行查询sql语句 并把数据库表中记录返回到ResultSet对象中进行保存。
ResultSet rs = statement.executeQuery(sql);
//取出ResultSet中表的记录。rs.next() 判断指针是否可以移动。如果可以移动则返回true,否则返回false
while (rs.next()) {
int id = rs.getInt("id"); //指针移动并获取指定列的值。
String name = rs.getString("name");
String address=rs.getString("address");
int age=rs.getInt("age");
System.out.println("id:"+id+";name:"+name+";age:"+age+";address:"+address);
}
}分析查询：
2.1 根据条件查询
//根据条件查询数据库
@Test
public void testQueryByCondition() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai", "root", "root");
Statement statement = conn.createStatement();
String sql="select * from t_student where id=3";
ResultSet rs = statement.executeQuery(sql);
while (rs.next()){
int id = rs.getInt("id"); //指针移动并获取指定列的值。
String name = rs.getString("name");
String address=rs.getString("address");
int age=rs.getInt("age");
System.out.println("id:"+id+";name:"+name+";age:"+age+";address:"+address);
}
}3.sql注入安全问题
演示sql注入的安全问题:
//演示sql注入的安全问题
public static void main(String [] args) throws Exception{
Scanner scanner=new Scanner(System.in); //Scanner类有没有讲过。
System.out.print("请输入账号:");
String username = scanner.nextLine();
System.out.print("请输入密码:");
String password = scanner.nextLine(); //你输入的账号和密码 nextLine() 可以输入空格 回车任认为结束 next()输入空格后认为输入结束。
boolean b = sqlSafe(username, password);
}
//根据name查询数据 abc 演示的根据账号和密码查询数据库表记录 如果能查询表示登录成功 否则登录失败
private static boolean sqlSafe(String name,String password) throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai", "root", "root");
Statement statement = conn.createStatement();
//这里的admin 是不是一个死数据 123456 也是一个死数据
String sql="select * from t_user where username='"+name+"' and password='"+password+"'";
System.out.println(sql);
ResultSet rs = statement.executeQuery(sql);
while (rs.next()){
System.out.println("登录成功");
return true;
}
System.out.println("登录失败");
return false;
}
可以发现: 你的账号可以随便输入 你的密码也可以随便输入 但是 在输入密码时 or '4'='4 只要这个条件成立，那么你就能登录成功。 这个就是sql注入的安全问题。只要根据条件做sql。那么就会出现sql注入安全问题。
如何解决sql安全注入问题:
1. 前端做校验: --只防君子 防不了小人。
2. 后端也做校验:--难道以后每次写功能都进行校验吗? 代码变得复杂了。
3. 执行sql的类Statement出现了问题，后期PrepareStatement该类来解决sql注入安全问题。Statement和PrepareStatement区别?
Statement会出现sql注入安全问题。Preparestatement不会出现sql注入安全问题。
Preparestatement是Statement的子类。就是因为早期使用Statement发现该类出现问题，后期维护人员创建Statement的子类来解决这个问题。注意:维护人员不会再原类上做维护，
3.1使用prepareStatement来解决sql注入的问题。
//演示sql注入的安全问题
public static void main(String [] args) throws Exception{
Scanner scanner=new Scanner(System.in); //Scanner类有没有讲过。
System.out.print("请输入账号:");
String username = scanner.nextLine();
System.out.print("请输入密码:");
String password = scanner.nextLine(); //你输入的账号和密码 nextLine() 可以输入空格 回车任认为结束 next()输入空格后认为输入结束。
boolean b = sqlSafe02(username, password);
}
private static boolean sqlSafe02(String name,String password) throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai", "root", "root");
//使用PrepareStatement 这里的? 是占位符。
String sql="select * from t_user where username=? and password=?";
PreparedStatement ps = conn.prepareStatement(sql);//预编译sql
//为占位符赋值。根据占位符的类型使用不同的方法来赋值
ps.setString(1,name); //1表示第一个占位符 name:表示第一个占位符的值
ps.setString(2,password);
//执行sql语句
ResultSet rs = ps.executeQuery();
while (rs.next()){
System.out.println("登录成功");
return true;
}
System.out.println("登录失败");
return false;
}
PrepareStatement和Statement这两个类在代码上的区别：
3.2. 完成增删改查--使用PreparedStatement
@Test
public void testDelete() throws Exception {
Class.forName("com.mysql.cj.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
String user="root";
String pwd="root";
Connection connection = DriverManager.getConnection(url,user,pwd);
String sql="delete from t_student where id=?";
PreparedStatement ps = connection.prepareStatement(sql);
//为占位符赋值.
int id=5; //未来应该是传递过来的。
ps.setObject(1,id); //数据库中如果是其他类型 也可以使用''
//使用setObject
//执行sql语句 executeUpdate方法
ps.executeUpdate();
}package Day5_05;
import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* @Description:
* @Author:LouFangRui
*/
public class Test01 {
//增加
@Test
public void add() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection= DriverManager.getConnection
("jdbc:mysql://localhost:3306/student?serverTimezone=Asia/Shanghai","root","123456");
//定义sql语句
String sql="insert into t_student values(?,?,?,?)";
PreparedStatement ps=connection.prepareStatement(sql);
//为占位符赋值
ps.setObject(1,null);
ps.setObject(2,"阿呆");
ps.setObject(3,5);
ps.setObject(4,"春日部");
//执行sql语句
ps.executeUpdate();
}
//删除
@Test
public void delete() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection= DriverManager.getConnection
("jdbc:mysql://localhost:3306/student?serverTimezone=Asia/Shanghai","root","123456");
String sql2="delete from t_student where name=?";
PreparedStatement ps2=connection.prepareStatement(sql2);
//为占位符赋值
ps2.setObject(1,"李四");
ps2.executeUpdate();
}
//修改
@Test
public void change() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection= DriverManager.getConnection
("jdbc:mysql://localhost:3306/student?serverTimezone=Asia/Shanghai","root","123456");
//定义sql语句
String sql="update t_student set name='妮妮',age=5,address='春日部' where id=?";
PreparedStatement ps=connection.prepareStatement(sql);
//为占位符赋值
ps.setObject(1,4);
//执行语句
ps.executeUpdate();
}
//查询
@Test
public void select() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection= DriverManager.getConnection
("jdbc:mysql://localhost:3306/student?serverTimezone=Asia/Shanghai","root","123456");
//定义sql语句
String sql="select * from t_student where address=?";
PreparedStatement ps=connection.prepareStatement(sql);
//为占位符赋值
ps.setObject(1,"春日部");
ResultSet rs=ps.executeQuery();
while(rs.next()){
Object id=rs.getObject("id");
Object name=rs.getObject("name");
Object age=rs.getObject("age");
Object address=rs.getObject("address");
System.out.println("编号:"+id+" 名字:"+name+"年龄:"+age+"住址:"+address);
}
}
}
总结：
sql注入的安全问题解决方案.
(1)加载驱动:Class.forName("mysql驱动名称");
(2)获取连接对象:Connection conn=DriverManager.getConnection(url,u,pass);
(3)获取执行sql语句的对象:
PreparedStatement ps=conn.prepareStatement(sql);//预编译sql
(4)为占位符赋值
ps.setXXX(index,value); //index:表示占位符的索引。value:表示占位符的值
(5)执行sql语句。
ps.executeUpdate();//执行增删改的sql
ResultSet rs=ps.executeQuery();//执行查询的sql
(6)遍历ResultSet中的内容.
while(rs.next()){ //判断指针是否可以移动，如果可以移动则移动到下一行记录
rs.getXXX("列名"); //获取当前行的指定列的值。
}
4. 封装实体类
4.1 把查询的结果封装到相应的实体上
注意: 我们这里把查询的结果直接输出到控制台了，而实际开发中，我们需要把查询的结果展示到浏览器网页上，效果如下
如何把查询的结果封装起来：
1. 把数据库中每张表封装成一个类---简称实体类。
2. 把表中的列封装成实体类中的属性。
3. 表中的每条记录封装成实体类的对象。
4. 表中多条记录封装成集合ArrayList。
@Test
public void testSelect() throws Exception {
Class.forName("com.mysql.cj.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
String user = "root";
String password = "root";
Connection connection = DriverManager.getConnection(url, user, password);
String sql = "select * from tb_dept"; //因为这里没有占位符 所以可以不用为占位符赋值
PreparedStatement ps= connection.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
List<Dept> list = new ArrayList<>(); //集合存放数据库表中所有记录
while (rs.next()){
int id = rs.getInt("id");
String name = rs.getString("name");
//创建一个实体类对象 存储表中的一条记录。
Dept d = new Dept();
d.setId(id);
d.setName(name);
list.add(d);
}
System.out.println(list); //正常再开发中应该把该对象list返回给前端。
} @Test
public void testSelectOne() throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
String url = "jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
String user = "root";
String password = "root";
Connection connection = DriverManager.getConnection(url, user, password);
String sql = "select * from tb_dept where id=?"; //这里根据id查询的结果一定是一条记录。因为id是主键。
PreparedStatement ps= connection.prepareStatement(sql);
ps.setInt(1,9);
ResultSet rs = ps.executeQuery();
Dept d=null;//声明部门实体类对象。
while (rs.next()){
d = new Dept(); //因为进入该语句表示从数据库中查询到相应的记录了。
int id = rs.getInt("id");
String name = rs.getString("name");
d.setId(id);
d.setName(name);
}
System.out.println(d); //以后可以把d返回给前端调用者
}如果查询的结果为多条记录使用ArrayList存储多条记录而每一条还是用实体类对象。
如果查询的结果确定为一条，直接使用实体类。
4.2 把对每一张表的操作封装到相应的类上
思考: 我们如果把所有表的操作都写在一个类中，那么该类的代码会变得越来越容重，对应后期维护也不方便，真正再企业开发时我们会对每张表得操作都封装一个对应得操作类。
后缀都是Dao -----Data access Object 数据访问对象层
tb_dept 对应一个操作类 DeptDao该操作类中包含所有对tb_dept表得增删改查得操作。
tb_student 对应一个操作 StudentDao
public class DeptDao {
private String driverName="com.mysql.cj.jdbc.Driver";
private String url="jdbc:mysql://localhost:3306/mydb?serverTimezone=Asia/Shanghai";
private String user="root";
private String password="root";
//根据id查询部门信息
public Dept findOne(int id) throws Exception{
Class.forName(driverName);
Connection connection = DriverManager.getConnection(url, user, password);
String sql = "select * from tb_dept where id=?"; //这里根据id查询的结果一定是一条记录。因为id是主键。
PreparedStatement ps= connection.prepareStatement(sql);
ps.setInt(1,id);
ResultSet rs = ps.executeQuery();
Dept d=null;//声明部门实体类对象。
while (rs.next()){
d = new Dept(); //因为进入该语句表示从数据库中查询到相应的记录了。
d.setId(rs.getInt("id"));
d.setName(rs.getString("name"));
}
return d;
}
//查询操作--查询所有
public List<Dept> findAll() throws Exception{
List<Dept> list=new ArrayList<>();
Class.forName(driverName);
Connection connection = DriverManager.getConnection(url,user,password);
String sql= "select * from tb_dept";
PreparedStatement ps=connection.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next()){
//创建一个实体类对象 存储表中的一条记录。
Dept d = new Dept();
d.setId(rs.getInt("id"));
d.setName(rs.getString("name"));
list.add(d);
}
return list;
}
//增加操作--要不要传递参数
public void insertDept(Dept dept) throws Exception{ //把前端输入得部门信息封装到相应得实体类。
Class.forName(driverName);
Connection connection = DriverManager.getConnection(url,user,password);
String sql = "insert into tb_dept values(null,?)";
PreparedStatement ps = connection.prepareStatement(sql);
ps.setObject(1,dept.getName());
ps.executeUpdate();
}
//删除操作--根据id删除
public void delete(int id)throws Exception{
Class.forName(driverName);
Connection connection = DriverManager.getConnection(url,user,password);
String sql = "delete from tb_dept where id=?";
PreparedStatement ps = connection.prepareStatement(sql);
ps.setObject(1,id);
ps.executeUpdate();
}
}4.3 使用try-catch-finally来处理异常
//查询操作--查询所有
public List<Dept> findAll() {
List<Dept> list = new ArrayList<>();
try {
Class.forName(driverName);
connection = DriverManager.getConnection(url, user, password);
String sql = "select * from tb_dept";
ps = connection.prepareStatement(sql);
rs = ps.executeQuery();
while (rs.next()) {
//创建一个实体类对象 存储表中的一条记录。
Dept d = new Dept();
d.setId(rs.getInt("id"));
d.setName(rs.getString("name"));
list.add(d);
}
} catch (Exception exception) {
exception.printStackTrace();
} finally {
try {
if(rs!=null){
rs.close();
}
if(ps!=null){
ps.close();
}
if(connection!=null){
connection.close();
}
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
return list;
}练习：
对该表进行操作---封装实体类 和 操作类（添加 删除 修改 查询所有 根据id查询单条记录）。
1. 把数据库中的表封装成一个类---简称实体类。
package com.lfr.entity;
/**
* @Description:
* @Author:LouFangRui
*/
public class Student {
private int id;
private String name;
private int age;
private String address;
//getter、setter方法
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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
//toString
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
2.增删改查 （操作类）
package com.lfr.dao;
import com.lfr.entity.Student;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
/**
* @Description:
* @Author:LouFangRui
*/
public class StudentDao {
PreparedStatement ps=null;
Connection connection=null;
ResultSet rs=null;
String url="jdbc:mysql://localhost:3306/student?serverTimezone=Asia/Shanghai";
String user="root";
String password="123456";
//查询学生信息（id查询）
public Student findOne(int id)throws Exception{
Class.forName("com.mysql.cj.jdbc.Driver");
connection= DriverManager.getConnection(url,user,password);
String sql="select *from t_student where id=?";
ps=connection.prepareStatement(sql);
ps.setInt(1,id);
rs=ps.executeQuery();
//声明实体类对象
Student a=null;
while (rs.next()){
a=new Student();
a.setId(rs.getInt("id"));
a.setName(rs.getString("name"));
a.setAge(rs.getInt("age"));
a.setAddress(rs.getString("address"));
}
return a;
}
//查询操作(查询全部)
public List<Student> findAll() {
List<Student> list=new ArrayList<>();
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection= DriverManager.getConnection(url,user,password);
String sql="select * from t_student";
ps=connection.prepareStatement(sql);
rs=ps.executeQuery();
while (rs.next()){
//创建实体类对象，储存表中记录
Student b = new Student();
b.setId(rs.getInt("id"));
b.setName(rs.getString("name"));
b.setAge(rs.getInt("age"));
b.setAddress(rs.getString("address"));
list.add(b);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
ps.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
return list;
}
//增加操作
public void insertStudent(Student student){
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection=DriverManager.getConnection(url,user,password);
String sql="insert into t_student values(null,?,?,?)";
ps=connection.prepareStatement(sql);
ps.setObject(1,student.getName());
ps.setObject(2,student.getAge());
ps.setObject(3,student.getAddress());
ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if (ps != null) {
ps.close();
}
if (connection != null) {
connection.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
//删除操作（根据id删除）
public void delete(int id){
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection=DriverManager.getConnection(url,user,password);
String sql="delete from t_student where id=?";
ps=connection.prepareStatement(sql);
ps.setInt(1,id);
ps.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if (ps != null) {
ps.close();
}
if (connection != null) {
connection.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
//修改操作
public void change(String name,int age,String address,int id){
try {
Class.forName("com.mysql.cj.jdbc.Driver");
Connection connection=DriverManager.getConnection(url,user,password);
String sql="update t_student set name=?,age=?,address=? where id=?";
ps=connection.prepareStatement(sql);
ps.setString(1,name);
ps.setInt(2,age);
ps.setString(3,address);
ps.setInt(4,id);
ps.executeUpdate();
} catch (Exception throwables) {
throwables.printStackTrace();
} finally {
try {
if (ps!=null){
ps.close();
}if (connection!=null){
connection.close();
}
} catch (Exception throwables) {
throwables.printStackTrace();
}
}
}
}
3.测试增删改
package com.lfr.demo;
import com.lfr.dao.StudentDao;
import com.lfr.entity.Student;
import org.junit.Test;
import java.util.List;
/**
* @Description:
* @Author:LouFangRui
*/
public class TestStudent1Dao {
StudentDao studentDao=new StudentDao();
//测试条件查询
@Test
public void testSelectOne() throws Exception{
Student one=studentDao.findOne(5);
System.out.println("id:\t"+one.getId()+" name:\t"+one.getName()+" age:\t"+one.getAge()+" address:\t"+one.getAddress());
}
//测试表格内容全部查询
@Test
public void testSelectAll(){
List<Student> all=studentDao.findAll();
for (Student a:all){
System.out.println("id:\t"+a.getId()+" name:\t"+a.getName()+" age:\t"+a.getAge()+" address:\t"+a.getAddress());
}
}
//测试添加方法
@Test
public void testAdd(){
Student student=new Student();
student.setName("小新");
student.setAge(5);
student.setAddress("野原家");
studentDao.insertStudent(student);
System.out.println(student);
}
//测试删除方法
@Test
public void testDelete(){
studentDao.delete(7);
}
//测试修改方法
@Test
public void testUpdate(){
studentDao.change("小新",5,"野原家",1);
}
}
5.抽取一个dao的公共的父类
5.1 为什么要抽取父类
因为我们对每一张表都封装了一个操作类，那么再数据库中有很多表，那么我们就会有很多操作类，这些操作类都有一些公共的代码，为了减少代码的冗余，我们就抽取了一个父类。
package com.lfr.dao;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* @Description:
* @Author:LouFangRui
*/
public class BaseEmpDao {
//公共属性
private String drivername="com.mysql.cj.jdbc.Driver";
private String url="jdbc:mysql://localhost:3306/student?serverTimezone=Asia/Shanghai";
private String user="root";
private String password="123456";
protected Connection connection=null;
protected PreparedStatement ps=null;
protected ResultSet rs=null;
//获取链接对象的方法
public Connection getConnection() throws Exception{
//此处需要抛出异常
Class.forName(drivername);
connection=DriverManager.getConnection(url,user,password);
return connection;
}
//关闭资源的方法
public void closeAll(){
try {
if(ps!=null){
ps.close();
}if(connection!=null){
connection.close();
}if (rs!=null){
rs.close();
}
}catch (Exception e){
e.printStackTrace();
}
}
}
5.2 为添加 删除 修改抽取公共的方法
父类的代码：
//抽取一个增删改 公共方法
public void edit(String sql,Object...params){
try {
connection=getConnection();
ps=connection.prepareStatement(sql);
//为占位符赋值
for (int i=0;i<params.length;i++){
ps.setObject(i+1,params[i]);
}
ps.executeUpdate();
}catch (Exception e){
e.printStackTrace();
}finally {
closeAll();
}
}子类的代码：
//增加
public void insert(Emp emp){
String sql="insert into tb_emp values(null,?,?,?,?,?,?,?)";
edit(sql,emp.getName(),emp.getAge(),
emp.getJob(),emp.getSalary(),emp.getEntrydate(),
emp.getManagerid(),emp.getDept_id());
}
//修改
public void update(Emp emp){
String sql="update tb_emp set name=?,age=?,job=?,salary=?,entrydate=?,managerid=?,dept_id=? where id=?";
edit(sql,emp.getName(),emp.getAge(),emp.getJob(),
emp.getSalary(),emp.getEntrydate(),
emp.getManagerid(),emp.getDept_id(),emp.getId());
}
//删除
public void delete(int id){
String sql="delete from tb_emp where id=?";
edit(sql,id);
}抽取父类后对表进行增删改查：
package com.lfr.dao;
import com.lfr.entity.Emp;
import java.util.ArrayList;
import java.util.List;
/**
* @Description:
* @Author:LouFangRui
*/
public class EmpDao extends BaseEmpDao{
public List<Emp> selectAll() {
List<Emp> list=new ArrayList<>();
try {
String sql="select * from tb_emp ";
connection=getConnection();
ps=connection.prepareStatement(sql);
rs=ps.executeQuery();
while (rs.next()){
Emp a = new Emp();
a.setId(rs.getInt("id"));
a.setName(rs.getString("name"));
a.setAge(rs.getInt("age"));
a.setJob(rs.getString("job"));
a.setSalary(rs.getInt("salary"));
a.setEntrydate(rs.getString("entrydate"));
a.setManagerid(rs.getInt("managerid"));
a.setDept_id(rs.getInt("dept_id"));
list.add(a);
}
}catch (Exception e){
e.printStackTrace();
}finally {
closeAll();
}
return list;
}
//id条件查询
public Emp selectId(int id) throws Exception{
Emp b=null;
connection=getConnection();
String sql="select * from tb_emp where id=?";
ps=connection.prepareStatement(sql);
ps.setInt(1,id);
rs=ps.executeQuery();
while (rs.next()){
b = new Emp();
b.setId(rs.getInt("id"));
b.setName(rs.getString("name"));
b.setAge(rs.getInt("age"));
b.setJob(rs.getString("job"));
b.setSalary(rs.getInt("salary"));
b.setEntrydate(rs.getString("entrydate"));
b.setManagerid(rs.getInt("managerid"));
b.setDept_id(rs.getInt("dept_id"));
}
return b;
}
//增加
public void insert(Emp emp){
String sql="insert into tb_emp values(null,?,?,?,?,?,?,?)";
edit(sql,emp.getName(),emp.getAge(),
emp.getJob(),emp.getSalary(),emp.getEntrydate(),
emp.getManagerid(),emp.getDept_id());
}
//修改
public void update(Emp emp){
String sql="update tb_emp set name=?,age=?,job=?,salary=?,entrydate=?,managerid=?,dept_id=? where id=?";
edit(sql,emp.getName(),emp.getAge(),emp.getJob(),
emp.getSalary(),emp.getEntrydate(),
emp.getManagerid(),emp.getDept_id(),emp.getId());
}
//删除
public void delete(int id){
String sql="delete from tb_emp where id=?";
edit(sql,id);
}
}
增删改查测试：
package com.lfr.demo;
import com.lfr.dao.EmpDao;
import com.lfr.entity.Emp;
import org.junit.Test;
import java.util.List;
/**
* @Description:
* @Author:LouFangRui
* @Date:2022/5/8 22:17
*/
public class TsetEmpDao {
EmpDao empDao=new EmpDao();
//查询全部
@Test
public void testCheckAll(){
List<Emp> all=empDao.selectAll();
for (Emp a:all){
System.out.println("id:"+a.getId()+" name:"+a.getName()
+" age:"+a.getAge()+" job:"+a.getJob()+" salary:"+a.getSalary()
+" entrydate:"+a.getEntrydate()+"managerid:"+a.getManagerid()+" dept_id:"+a.getDept_id());
}
}
//条件查询（id）
@Test
public void testSelectId() throws Exception {
Emp a=empDao.selectId(5);
System.out.println("id:"+a.getId()+" name:"+a.getName()
+" age:"+a.getAge()+" job:"+a.getJob()+" salary:"+a.getSalary()
+" entrydate:"+a.getEntrydate()+"managerid:"+a.getManagerid()+" dept_id:"+a.getDept_id());
}
//删除
@Test
public void testDelete(){
empDao.delete(18);
}
//修改
@Test
public void testChange(){
Emp emp=new Emp();
emp.setName("蜡笔小新");
emp.setAge(5);
emp.setJob("销售");
emp.setSalary(3000);
emp.setEntrydate("2020-9-25");
emp.setManagerid(4);
emp.setDept_id(5);
emp.setId(1);
empDao.update(emp);
}
//添加
@Test
public void testAdd(){
Emp emp = new Emp();
emp.setName("金庸");
emp.setAge(50);
emp.setJob("总裁");
emp.setSalary(300000);
emp.setEntrydate("1999-9-25");
emp.setManagerid(4);
emp.setDept_id(5);
empDao.insert(emp);
}
}
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
