JDBC中的JAVAEE结构

一、JavaEE结构

客户端-服务器端

二、Dao模式(Data Access Object 数据访问对象)

  • 1.现将数据库和java连接的外接jar导入。将第一讲的类JDBC放入util包内，并且导入properties文件(student改为新的数据库user)。
  • 2.新建数据库为user，建立一个属性有id/name/password的表t_user

  • 3.建立四个包：dao(里面声明数据库访问规则) impl(具体实现早前定义的规则) test(直接使用实现) util
  • 4.dao包内建立一个UserDao的接口
1
2
3
4
5
6
7
8
9
package dao;

import java.sql.SQLException;

public interface UserDao {
		
		void findAll() throws SQLException;  //里面写具体要干的方法
		
}
  • 5.impl包内建立一个UserDaoImp类—>UserDao接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package impl;
import java.sql.ResultSet;
import java.sql.SQLException;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.Statement;
import dao.UserDao;
import util.JDBC;
public class UserDaoImp implements UserDao{   ///实现UserDao的接口 去完成具体实现代码

	@Override
		public void findAll() throws SQLException {
			//1.获得连接对象
			java.sql.Connection conn=JDBC.getConn();
			
			//2.根据连接对象，得到statement
			java.sql.Statement st=null;
			try {
				st = conn.createStatement();
			} catch (Exception e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			
			//3.执行sql语句，返回ResultSet
			String sql="select * from t_user";  //写sql语句		
			ResultSet rs = st.executeQuery(sql);//返回给ResultSet对象   st连接对象去调用Query方法
			
			//4.遍历	
			while(rs.next())
			{
				int id=rs.getInt("id");
				String name=rs.getString("name");
				String age=rs.getString("password");
				System.out.println("id="+id+" name="+name+" age="+age);
			}
						
		}		
}
  • 6.test包内建立testUserDaoImpl类去使用Junit单元测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package test;
import java.sql.SQLException;
import org.junit.Test;
import dao.UserDao;
import impl.UserDaoImp;
public class testUserDaoImpl {
	
	@Test  //点击项目右键选择Junit单元测试的(4)---然后@Test即可
		public void testFindAll() throws SQLException
		{
			UserDao dao=new UserDaoImp();  //面向接口编程
			dao.findAll();  //对象调用方法
		}
		
}

  • 7.util包内存放的就是原来写好的JDBC类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package util;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.Driver;
import com.mysql.jdbc.Statement;
public class JDBC{
		//写在外面好更改
		static String driverClass=null;
		static String url=null;
		static String name=null;;
		static String password=null;
	
		static{
			
			//1.创建一个属性配置对象
			Properties properties=new Properties();
			
			InputStream is=JDBC.class.getClassLoader().getResourceAsStream("properties");  //类.class.getClassLoader().getResourceAsStream("文件名");
			//2.导入输入流
			try {
				properties.load(is);  //load方法加载
			} catch (IOException e) {
				e.printStackTrace();
			}
			
			//3.调用方法读取文档里面的url/name/password等
			driverClass=properties.getProperty("driverClass");
			url=properties.getProperty("url");
			name=properties.getProperty("name");
			password=properties.getProperty("password");
		}
	
		public static java.sql.Connection getConn(){
			java.sql.Connection conn=null;
			//1.注册驱动
			//DriverManager.registerDriver(new Driver());   //需要一个参数    这个参数是java.sql.jdbc.Driver
			try {
				Class.forName(driverClass);
			} catch (ClassNotFoundException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			//2.建立连接(url协议+数据库,user账号,password密码)
			try {
				conn=DriverManager.getConnection(url,name,password);
			} catch (SQLException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			return conn;			
		}
	
	public static void main(String[] args) throws SQLException{			
		java.sql.Connection conn = getConn();
		//3.创建statement，跟数据库打交道，一定需要这个对象
		java.sql.Statement st=conn.createStatement();
		
		//4.执行查询
		String sql="select * from s_stu";
		ResultSet rs=st.executeQuery(sql);
		
		//5.遍历每一条查询
		while(rs.next())  //是否可以移动到下一行
		{ 
			int id=rs.getInt("id");  //获得id
			String name=rs.getString("name");  //获得name
			int age=rs.getInt("age");  //获得age		
			System.out.println("id="+id+"    name="+name+"   age="+age);			
		}
		
		//6.释放
		rs.close();	
	}

	public static void release(java.sql.Connection conn, java.sql.Statement st, ResultSet rs) {
		// TODO 自动生成的方法存根
		
	}
}
  • 8.properties文件内内容：
1
2
3
4
driverClass=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost/user
name=root
password=njdxrjgc7777777.

代码实现框架：

三、增加登录界面

1. Dao包的UserDao类增加一个 login方法

1
void login(String username,String password) throws SQLException;

2. impl包的UserDaoImp增加一个实现方法(只是更改了sql语句)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public void login(String username,String password) throws SQLException {
			//1.获得连接对象
			java.sql.Connection conn=JDBC.getConn();
			
			//2.根据连接对象，得到statement
			java.sql.Statement st=null;
			try {
				st = conn.createStatement();
			} catch (Exception e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
			
			//3.执行sql语句，返回ResultSet
			String sql="select * from t_user where name='"+  username +"' and password='"+ password +"'";  //写sql语句		
			ResultSet rs = st.executeQuery(sql);//返回给ResultSet对象   st连接对象去调用Query方法
			
			//4.遍历	
			if(rs.next())
			{
				System.out.println("成功");
			}
			else
			{
				System.out.println("失败");
			}
			
		}

3. test包内的testUserDaoImpl类增加一个调用方法(dao.login(“xxx”,”yyy”))

1
dao.login("admin","10086");

四、statement安全问题

执行原理：是进行拼接sql语句的过程(先拼接，后执行)

五、PreparedStatement

更改目录代码(主要是2.3步更改)

  • 原来的statement是先创建statement对象，然后书写sql语句最后进行调用executeQuery()方法
  • 现在的preparedstatement是先写sql语句(判定条件都写？),然后调用方法去检验,之后使用setString()方法进行，最后调用executeQuery()方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public void login(String username,String password) throws SQLException {
			//1.获得连接对象
			java.sql.Connection conn=JDBC.getConn();
			
			//2.预先对sql语句校验(?把它认为是字符串)
			String sql="select * from t_user where name=? and password=?";  //写sql语句	"
			java.sql.PreparedStatement  ps=conn.prepareStatement(sql);
			//？对应的索引从1开始
			ps.setString(1, username);
			ps.setString(2, password);
			
			ResultSet rs = ps.executeQuery();//返回给ResultSet对象   st连接对象去调用Query方法
			
			//4.遍历	
			if(rs.next())
			{
				System.out.println("成功");
			}
			else
			{
				System.out.println("失败");
			}
			
		}
  • 总结：

1. 先写sql语句(增删查改)

1
String sql="select * from t_user where name=? and password=?";  //写sql语句    "

2. 预先对sql语句校验(?把它认为是字符串)

1
2
3
java.sql.PreparedStatement  ps=conn.prepareStatement(sql);
ps.setString(1, username);
ps.setString(2, password);

3. 调用方法进行执行

1
ResultSet rs = ps.executeQuery();

六、利用preparedstatment—-增删查改

1. dao包里面的UserDao类里面写增删查改的方法

1
2
3
4
5
6
7
8
9
10
11
12
public interface UserDao {
	
	void update(int id , String name);  //更新(利用id去更新)
	
	void delete(int id);  //删除(利用id去删除)
	
	void insert(String userName , String password);  //插入(id可以通过sql语句自己写)
		
	void findAll(); //查询展示所有的
	
	void login(String username , String password); //登录
}

2. impl包里面的UserDaoImpl类里面写增删查改的具体实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
public class UserDaoImpl implements UserDao{

	@Override
	public void findAll() {
		Connection conn = null;
		Statement st = null;
		ResultSet rs = null;
		try {
			//1. 获取连接对象
			conn = JDBCUtil.getConn();
			//2. 创建statement对象
			st = conn.createStatement();
			String sql = "select * from t_user";
			rs = st.executeQuery(sql);
			
			while(rs.next()){
				String userName = rs.getString("username");
				String password = rs.getString("password");		
				System.out.println(userName+"="+password);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JDBCUtil.release(conn, st, rs);
		}
	}
	
	@Override
	public void login(String username, String password) {  //登录
		
		Connection conn = null;
		Statement st = null;
		ResultSet rs = null;
		try {
			//1. 获取连接对象
			conn = JDBCUtil.getConn();
			//2. 创建statement对象 
			String sql = "select * from t_user where username=? and password=?";
			
			//预先对sql语句执行语法的校验， ? 对应的内容，后面不管传递什么进来，都把它看成是字符串。 or select 
			PreparedStatement ps = conn.prepareStatement(sql);
			//? 对应的索引从 1 开始。 
			ps.setString(1, username);
			ps.setString(2, password);
			
			rs = ps.executeQuery();
			if(rs.next()){
				System.out.println("登录成功");
			}else{
				System.out.println("登录失败");
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			JDBCUtil.release(conn, st, rs);
		}
	}

	
	
	
	@Override
	public void insert(String userName, String password) {  //插入
		Connection conn = null;
		PreparedStatement ps = null;
		
		try {
			 conn = JDBCUtil.getConn();
			String sql = "insert into t_user values(null , ? , ?)";
			 ps = conn.prepareStatement(sql);
			 
			 //给占位符赋值 从左到右数过来，1 代表第一个问号， 永远你是1开始。
			 ps.setString(1, userName);
			 ps.setString(2, password);
			 
			 
			int result = ps.executeUpdate();
			if(result>0){
				System.out.println("添加成功");
			}else{
				System.out.println("添加失败");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			JDBCUtil.release(conn, ps);
		}
	}

	@Override
	public void delete(int id) {  //删除
		Connection conn = null;
		PreparedStatement ps = null;
		
		try {
			 conn = JDBCUtil.getConn();
			String sql = "delete from t_user where id = ?";
			 ps = conn.prepareStatement(sql);
			 
			 //给占位符赋值 从左到右数过来，1 代表第一个问号， 永远你是1开始。
			 ps.setInt(1, id);
			 
			 
			int result = ps.executeUpdate();
			if(result>0){
				System.out.println("删除成功");
			}else{
				System.out.println("删除失败");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			JDBCUtil.release(conn, ps);
		}
	}

	@Override
	public void update(int id, String name) {  //更新
		Connection conn = null;
		PreparedStatement ps = null;
		
		try {
			 conn = JDBCUtil.getConn();
			String sql = "update t_user set username=? where id =?";
			 ps = conn.prepareStatement(sql);
			 
			 //给占位符赋值 从左到右数过来，1 代表第一个问号， 永远你是1开始。
			 ps.setString(1, name);
			 ps.setInt(2, id);
			 
			 
			int result = ps.executeUpdate();
			if(result>0){
				System.out.println("更新成功");
			}else{
				System.out.println("更新失败");
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}finally{
			JDBCUtil.release(conn, ps);
		}
	}


}

3. test包里面的TestUserDaoImpl类里面写增删查改的直接调用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class TestUserDaoImpl {
	@Test
	public void testInsert(){  //测试插入
		
		UserDao dao = new UserDaoImpl();
		
		dao.insert("aobama", "911");
	}

	@Test 
	public void testUpdate(){  //测试更新
		
		UserDao dao = new UserDaoImpl();
		
		dao.update(2, "itheima");
	}	

	@Test
	public void testDelete(){ //测试删除
		
		UserDao dao = new UserDaoImpl();
		
		dao.delete(30);
	}

	@Test
	public void testFindAll(){  //测试查询所有
		
		//面向父类编程 接口编程
		UserDao dao = new UserDaoImpl(); //体现多态的特征 
		dao.findAll();
	}

	@Test
	public void testLogin(){
		UserDao dao = new UserDaoImpl();
		dao.login("admin", "100234khsdf88' or '1=1");
	}

}

赏

×

纯属好玩

扫码支持
扫码打赏，你说多少就多少

打开支付宝扫一扫，即可进行扫码打赏哦

本文标题:JDBC中的JAVAEE结构

文章作者:Larkkkkkkk

发布时间:2020年02月14日 - 10时41分

最后更新:2020年02月15日 - 12时46分

原始链接:https://larkkkkkkk.github.io/2020/02/14/JDBC%E4%B8%AD%E7%9A%84JAVAEE%E7%BB%93%E6%9E%84/

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 一、JavaEE结构
  2. 2. 二、Dao模式(Data Access Object 数据访问对象)
  3. 3. 三、增加登录界面
  4. 4. 四、statement安全问题
  5. 5. 五、PreparedStatement
  6. 6. 六、利用preparedstatment—-增删查改
,