JDBC也就那么回事
JDBC
一、JDBC概述
为什么要使用JDBC？
JDBC：Java DataBase Connectivity，是SUN公司提供的一套操作数据库的标准规范(技术)。
JDBC与数据库驱动的关系：接口与实现的关系。
JDBC规范（掌握四个核心对象）：
DriverManager类：用于注册驱动(创建连接对象)。 java.sql.DriverManager;
Connection接口：表示与数据库创建的连接 。java.sql.Connection;
Statement接口：操作数据库sql语句的对象，并返回相应结果的对象。 java.sql.Statement;
preparedStatement接口：预编译对象，是Statement对象的子类。用于解决sql的注入问题。实际用的是这个类。java.sql.PreparedStatement;
ResultSet接口：结果集或一张虚拟表(客户端存表数据的对象)。 java.sql.ResultSet;
二、开发一个JDBC程序
使用JDBC技术，通过java代码实现查询数据库中的数据并显示在java的控制台中。
1、先创建数据库表，并向表中添加测试数据。
create database stu;
use stu; create table user (
id int primary key auto_increment,
username varchar(40),
password varchar(40),
) character set utf8 collate utf8_general_ci; insert into user(username, password) values('zs', '123456');
insert into user(username, password) values('lisi', '123456');
insert into user(username, password) values('wangwu', '123456');
2、创建Java Project项目，添加数据库驱动(xxx.jar)。
3、实现JDBC操作。
4.源码示例
package com.jdbc; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException; public class JDBCUtils {
public static Connection connection; private static String url ="jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8";
private static String user ="root";
private static String pwd = "root"; static{
try {
Class.forName("com.mysql.jdbc.Driver");
connection = DriverManager.getConnection(url,user,pwd);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
} public static Connection getConnection(){
return connection;
} }
package com.pojo;
public class User {
private int id;
private String username;
private String password;
public User() {
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
public User(int id, String username, String password) {
this.id = id;
this.username = username;
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
package com.dao; import com.jdbc.JDBCUtils;
import com.pojo.User; import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List; public class UserDao { private Connection conn = JDBCUtils.getConnection();
private PreparedStatement ps; /**
* 添加用户
* @param user 要添加的用户对象
* @throws SQLException
*/
public int add(User user) throws SQLException {
String sql = "insert into user(username,password) values(?,?)";
ps = conn.prepareStatement(sql);
ps.setObject(1,user.getUsername());
ps.setObject(2,user.getPassword());
return ps.executeUpdate();
} /**
* 删除
* @param id
* @return
* @throws SQLException
*/
public int delete(int id) throws SQLException {
String sql = "delete from user where id=?";
ps = conn.prepareStatement(sql);
ps.setObject(1,id);
return ps.executeUpdate();
} /**
* 修改
* @param user
* @return
* @throws SQLException
*/
public int update(User user) throws SQLException {
String sql = "update user set username=? , password=? where id=?";
ps = conn.prepareStatement(sql);
ps.setObject(1,user.getUsername());
ps.setObject(2,user.getPassword());
ps.setObject(3,user.getId());
return ps.executeUpdate();
} /**
* 查询所有
* @return
* @throws SQLException
*/
public List<User> findAll() throws SQLException {
String sql = "select * from user";
ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
List<User> list = new ArrayList<User>();
while(rs.next()){
int id = rs.getInt("id");
String username = rs.getString("username");
String password = rs.getString("password");
User u = new User(id,username,password);
list.add(u);
}
return list;
} /**
* 根据ID查询
* @param id
* @return
* @throws SQLException
*/
public User findByID(int id) throws SQLException {
String sql = "select * from user where id=?";
ps = conn.prepareStatement(sql);
ps.setInt(1,id); ResultSet rs = ps.executeQuery();
User u = null;
while(rs.next()){
int uid = rs.getInt("id");
String username = rs.getString("username");
String password = rs.getString("password");
u = new User(uid,username,password);
}
return u;
} /**
* 登录的方法
*/
public User login(User user) throws SQLException {
String sql = "select * from user where username=? and password=?";
ps = conn.prepareStatement(sql);
ps.setObject(1,user.getUsername());
ps.setObject(2,user.getPassword());
ResultSet rs = ps.executeQuery();
User u = null;
while(rs.next()){
int uid = rs.getInt("id");
String username = rs.getString("username");
String password = rs.getString("password");
u = new User(uid,username,password);
}
return u;
} }
package com.service; import com.dao.UserDao;
import com.pojo.User; import java.sql.SQLException;
import java.util.List; public class UserService { private UserDao userDao = new UserDao(); /**
* 添加用户
* @param user 要添加的用户对象
* @throws SQLException
*/
public int add(User user) throws SQLException {
return userDao.add(user);
} /**
* 删除
* @param id
* @return
* @throws SQLException
*/
public int delete(int id) throws SQLException {
return userDao.delete(id);
} /**
* 修改
* @param user
* @return
* @throws SQLException
*/
public int update(User user) throws SQLException {
return userDao.update(user);
} /**
* 查询所有
* @return
* @throws SQLException
*/
public List<User> findAll() throws SQLException {
return userDao.findAll();
} /**
* 根据ID查询
* @param id
* @return
* @throws SQLException
*/
public User findByID(int id) throws SQLException {
return userDao.findByID(id);
} /**
* 登录
*/
public User login(User user) throws SQLException {
return userDao.login(user);
} }
package com.jdbc; import com.pojo.User; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List; public class Demo {
public static void main(String[] args) throws Exception { //1.动态加载驱动
// Class.forName("com.mysql.cj.jdbc.Driver");
//
// //2.获取连接对象
// String url = "jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8";
// String user = "root";
// String pwd = "123456";
// Connection conn = DriverManager.getConnection(url, user, pwd); //3.使用jdbc规范实现CRUD
//String sql = "insert into user(username,password) value(?,?)";
// String sql ="select * from user ";
// // 创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。
// PreparedStatement ps = conn.prepareStatement(sql);
//
//// ps.setString(1,"晓峰");//将指定参数设置为给定 Java String 值
//// ps.setString(2,"xf");
//
//// ps.setObject(1,"军帅");//使用给定对象设置指定参数的值。
//// ps.setObject(2,"js");
//
////如果第一个结果是 ResultSet 对象，则返回 true；如果第一个结果是更新计数或者没有结果，则返回 false
//// boolean res = ps.execute();
//// System.out.println(res);
//
// //(1) SQL 数据操作语言 (DML) 语句的行数 (2) 对于无返回内容的 SQL 语句，返回 0
//// int rel = ps.executeUpdate();
//// System.out.println(rel);//1
//
// //ResultSet 对象具有指向其当前数据行的光标。最初，光标被置于第一行之前。next 方法将光标移动到下一行；
// //在此 PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
// ResultSet rs = ps.executeQuery();
//// rs.next();
//// rs.next();
//// rs.next();
//// rs.next();
//// boolean rel = rs.next();
//// System.out.println(rel);
//
// List<User> list = new ArrayList<User>();
//
// while (rs.next()){
//
// int id = rs.getInt(1);
// String username = rs.getString(2);
// String password = rs.getString(3);
//
//// User u = new User(id,username,password);
//// list.add(u);
// User u = (User) Class.forName("com.pojo.User").newInstance();
// list.add(u);
//
// }
//
// System.out.println(list); }
}
三、JDBC常用的类和接口详解
1、java.sql.Drivermanager类：注册驱动、建立连接
a、注册驱动
DriverManager.deregisterDriver(new com.mysql.jdbc.Driver()); // 不建议使用
原因有2个：
> 导致驱动被注册2次。
> 强烈依赖数据库的驱动jar包 （若把Build Path给Remove掉，代码就会报错，就能看到效果）
解决办法：
Class.forName("com.mysql.jdbc.Driver"); // 把Build Path给Remove掉，代码也不会报错了
用到反射机制的知识：靠类的全路径来加载，解耦合了，不依赖数据库的驱动jar包了，以后会把上面的字符串放在配置文件里，更灵活了，便于后期维护。
b、与数据库建立连接
DriverManager类的静态方法：
public static Connection getConnection(String url, String user, String password) 试图建立到给定数据库 URL 的连接
DriverManager.getConnection("jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8", "root", "root");
URL:是SUN公司与数据库厂商之间的一种协议。
jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8
协议 子协议 IP 数据库端口号 数据库名称
mysql:jdbc:mysql://localhost:3306/day14 或者
jdbc:mysql:///day14（默认连接本机的数据库）
oracle:jdbc:oracle:thin:@localhost:1521:sid 瘦客户端，比如：玩页游协议
子协议 子子协议 IP 数据库端口号 数据库名称
oracle:jdbc:oracle:thick:@localhost:1521:sid 胖客户端，比如：LOL、魔兽世界(需要下载软件)
与数据库建立连接的方式
第一种：
// public static Connection getConnection(String url, String user, String password)
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8", "root", "root");
第二种:
// public static Connection getConnection(String url, Properties info)
Properties info = new Properties(); // 要参考数据库文档
info.setProperty("username", "root");
info.setProperty("password", "root");
Connection conn = DriverManager.getConnection("jjdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8", info);
第三种：
// public static Connection getConnection(String url)
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/stu?serverTimezone=GMT%2B8?username=root&password=root");
// 模拟表单form提交的两种方式：GET和POST
实际开发常用第一种。
扩展内容：演示3个案例的话需要写3个main方法，所以有了快速测试的方法 ==> junit技术
}
-------------------------------------------
2、java.sql.Connection接口：一个连接(与数据库连接的一座桥梁)
该接口的实现在数据库驱动jar包中。所有与数据库交互都是基于连接对象的。
3、java.sql.Statement接口：操作sql语句，并返回相应结果的对象(小货车)
该接口的实现在数据库驱动jar包中。用于执行静态 SQL 语句并返回它所生成结果的对象。
// 客户端的叫法：create、read、update、delete （CRUD）（增删改查）
4、java.sql.ResultSet接口：结果集(客户端存表数据的对象)
a、封装结果集
提供一个游标，默认游标指向结果集第一行之前(即表头)。
调用一次boolean next()，游标向下移动一行。
提供一些getXxx()方法。
-------------------------------------------
将结果集中的数据封装到javaBean类中，javaBean就是一普通java类，该类中只有private类型的成员变量、无参构造方法和getter/setter方法。
java的数据类型与数据库中的类型的关系:
JAVA DB
byte tityint 1字节
short smallint 2字节
int int 4字节
long bigint 8字节
float float
double double
String char 或者 varchar
Date date
-------------------------------------------
ResultSet结果集封装数据的方法：
Object getObject(int columnIndex) 根据序号取值，索引从1开始
Object getObject(String ColomnName) 根据列名取值
boolean next() 将光标从当前位置向下移动一行
int getInt(int colIndex) 以int 形式获取ResultSet结果集当前行指定列号值
int getInt(String colLabel) 以int 形式获取ResultSet结果集当前行指定列名值
float getFloat(int colIndex) 以float 形式获取ResultSet结果集当前行指定列号值
float getFloat(String colLabel) 以float形式获取ResultSet结果集当前行指定列名值
String getString(int colIndex) 以String 形式获取ResultSet结果集当前行指定列号值
String getString(String colLabel) 以String 形式获取ResultSet结果集当前行指定列名值
Date getDate(int columnIndex) 以Date 形式获取ResultSet结果集当前行指定列号值
Date getDate(String columnName) 以Date 形式获取ResultSet结果集当前行指定列名
void close() 关闭ResultSet 对象
package com.itheima.entitydemo;
2
3 import java.util.Date;
4
5 /*
6 * 一般实体类的类名和数据库的表名一致。(注意：若数据库的表名单词带s的，则实体类名就去掉s)
7 * 实体类的成员变量名和数据库表中的列名一致。(这是一个约定，网站开发的时候会提到)
8 */
9 public class User {
10 private int id;
11 private String name;
12 private String password;
13 private String email;
14 private Date birthday;
15
16 public int getId() {
17 return id;
18 }
19
20 public void setId(int id) {
21 this.id = id;
22 }
23
24 public String getName() {
25 return name;
26 }
27
28 public void setName(String name) {
29 this.name = name;
30 }
31
32 public String getPassword() {
33 return password;
34 }
35
36 public void setPassword(String password) {
37 this.password = password;
38 }
39
40 public String getEmail() {
41 return email;
42 }
43
44 public void setEmail(String email) {
45 this.email = email;
46 }
47
48 public Date getBirthday() {
49 return birthday;
50 }
51
52 public void setBirthday(Date birthday) {
53 this.birthday = birthday;
54 }
55
56 @Override
57 public String toString() {
58 return "User [id=" + id + ", name=" + name + ", password=" + password + ", email=" + email + ", birthday="
59 + birthday + "]";
60 }
61
62 }
package com.itheima.entitydemo;
2
3 import java.sql.Connection;
4 import java.sql.DriverManager;
5 import java.sql.ResultSet;
6 import java.sql.Statement;
7 import java.util.ArrayList;
8 import java.util.List;
9
10 import org.junit.Test;
11
12 /*
13 * 服务器端叫法：insert、delete、update、select （增删改查）
14 * 客户端的叫法：create、read、update、delete （CRUD）（增删改查）
15 */
16 public class TestCRUD {
17
18 @Test
19 public void testSelect() throws Exception {
20 // 加载驱动
21 Class.forName("com.mysql.jdbc.Driver");
22
23 // 获取连接对象Connection(注意：能用接口的就不用实现类，多态=>对象上传=>向上转型=>里氏替换，利于后期代码扩展)
24 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
25
26 // 获取执行sql语句的对象Statement
27 Statement stmt = conn.createStatement();
28
29 // 执行sql的查询语句，并返回结果
30 ResultSet rs = stmt.executeQuery("select * from users");
31
32 // 把取到的数据装到集合中
33 List<User> list = new ArrayList<User>();
34
35 // 处理结果
36 User u = null;
37 while (rs.next()) {
38 u = new User();
39 u.setId(rs.getInt("id"));
40 u.setName(rs.getString("name"));
41 u.setPassword(rs.getString("password"));
42 u.setEmail(rs.getString("email"));
43 u.setBirthday(rs.getDate("birthday"));
44 list.add(u); // 把对象添加到集合中去
45 }
46
47 // 遍历集合(增强for)
48 for (User user : list) {
49 System.out.println(user);
50 }
51
52 // 关闭资源
53 rs.close();
54 stmt.close();
55 conn.close();
56 }
57
58 @Test
59 public void testInsert() throws Exception {
60 // 加载驱动
61 Class.forName("com.mysql.jdbc.Driver");
62
63 // 获取连接对象Connection(注意；能用接口的就不用实现类，多态=>对象上传=>向上转型=>里氏替换，利于后期代码扩展)
64 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
65
66 // 获取执行sql语句的对象Statement
67 Statement stmt = conn.createStatement();
68
69 // 执行sql的插入语句，并返回结果
70 int i = stmt.executeUpdate("INSERT INTO users VALUES (4, 'tom', '123','tom@163.com', '2015-09-28')");
71
72 // 处理返回的结果
73 if (i > 0) {
74 System.out.println("success");
75 }
76
77 // 关闭资源
78 stmt.close();
79 conn.close();
80 }
81
82 @Test
83 public void testUpdate() throws Exception {
84 // 加载驱动
85 Class.forName("com.mysql.jdbc.Driver");
86
87 // 获取连接对象Connection(注意；能用接口的就不用实现类，多态=>对象上传=>向上转型=>里氏替换，利于后期代码扩展)
88 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
89
90 // 获取执行sql语句的对象Statement
91 Statement stmt = conn.createStatement();
92
93 // 执行sql的更新语句，并返回结果
94 int i = stmt.executeUpdate("UPDATE users SET NAME = 'jerry', PASSWORD = '333', email = 'jerry@163.com' WHERE id = 4");
95
96 // 处理返回的结果
97 if (i > 0) {
98 System.out.println("success");
99 }
100
101 // 关闭资源
102 stmt.close();
103 conn.close();
104 }
105
106 @Test
107 public void testDelete() throws Exception {
108 // 加载驱动
109 Class.forName("com.mysql.jdbc.Driver");
110
111 // 获取连接对象Connection(注意；能用接口的就不用实现类，多态=>对象上传=>向上转型=>里氏替换，利于后期代码扩展)
112 Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
113
114 // 获取执行sql语句的对象Statement
115 Statement stmt = conn.createStatement();
116
117 // 执行sql的删除语句，并返回结果
118 int i = stmt.executeUpdate("DELETE FROM users WHERE id = 4");
119
120 // 处理返回的结果
121 if (i > 0) {
122 System.out.println("success");
123 }
124
125 // 关闭资源
126 stmt.close();
127 conn.close();
128 }
129
130 }
b、可移动游标的方法(现在很少用了，只有next()还常用)
5、释放资源
资源有限，要正确关闭。
原则：在使用对象之前，先判断对象是否为空。
package com.itheima.jdbcdemo;
2
3 import java.sql.Connection;
4 import java.sql.DriverManager;
5 import java.sql.ResultSet;
6 import java.sql.SQLException;
7 import java.sql.Statement;
8
9 /*
10 * 使用JDBC技术，通过java代码实现查询数据库中的数据并显示在java的控制台中。
11 *
12 * 演示正确释放资源。
13 *
14 * 把某一部分代码加上try...catch...的快捷键：Alt + Shift + Z
15 */
16 public class Demo4 {
17
18 public static void main(String[] args) {
19 // 获取连接对象Connection
20 Connection conn = null;
21 // 获取执行sql语句的对象Statement
22 Statement stmt = null;
23 // 执行sql查询语句，并返回结果
24 ResultSet rs = null;
25 try {
26 // 加载驱动
27 Class.forName("com.mysql.jdbc.Driver");
28 conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/day06", "root", "root");
29 stmt = conn.createStatement();
30 rs = stmt.executeQuery("select * from users");
31 // 处理返回的结果
32 while (rs.next()) {
33 // 根据列名取值，顺序自己定，更灵活
34 System.out.println(rs.getObject("id"));
35 System.out.println(rs.getObject("name"));
36 System.out.println(rs.getObject("password"));
37 System.out.println(rs.getObject("email"));
38 System.out.println(rs.getObject("birthday"));
39 }
40 } catch (Exception e) {
41 e.printStackTrace();
42 } finally {
43 // 关闭资源
44 if (rs != null) {
45 try {
46 rs.close();
47 } catch (SQLException e) {
48 e.printStackTrace();
49 }
50 }
51 if (stmt != null) {
52 try {
53 stmt.close();
54 } catch (SQLException e) {
55 e.printStackTrace();
56 }
57 }
58 if (conn != null) {
59 try {
60 conn.close();
61 } catch (SQLException e) {
62 e.printStackTrace();
63 }
64 }
65 }
66 }
67 }
四、使用JDBC实现CRUD操作
五、实现一个用户登录的功能
六、解决SQL注入问题：preparedStatement(预编译语句)
preparedStatement(接口)：预编译对象，是Statement(接口)对象的子类。
特点：（安全高效，防止恶义SQL语法）
1、性能要高；PreparedStatement 实例包含已编译的 SQL 语句，所以其执行速度要快于 Statement 对象。
2、会把sql语句先编译。
3、sql语句中的参数会发生变化，过滤掉用户输入的关键字。
package com.itheima.service; import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet; import com.itheima.entity.User;
import com.itheima.util.DBUtils; public class DoLogin { /**
* 根据姓名和密码查询用户信息
* @param name
* @param password
* @return User
*/
public User findUser(String name, String password) {
Connection conn = null;
// Statement stmt = null;
PreparedStatement stmt = null;
ResultSet rs = null;
User u = null; try {
conn = DBUtils.getConnection(); // stmt = conn.createStatement();
// String sql = "select * from users where name = '" + name + "' and password = '" + password + "'";
// rs = stmt.executeQuery(sql); String sql = "select * from users where name = ? and password = ?";
stmt = conn.prepareStatement(sql);
stmt.setString(1, name); // 给?赋值
stmt.setString(2, password); // 给?赋值
rs = stmt.executeQuery(); if (rs.next()) {
u = new User();
u.setId(rs.getInt("id"));
u.setName(rs.getString("name"));
u.setPassword(rs.getString("password"));
u.setEmail(rs.getString("email"));
u.setBirthday(rs.getDate("birthday"));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
DBUtils.closeAll(rs, stmt, conn); } return u;
}
}
JDBC也就那么回事的更多相关文章
- struts神马的不过是对servlet、filter的封装而已，hibernate神马的也不过是对jdbc的封装而已，他们只是把一些常见的操作流程化了，如果不懂servlet、filter，不懂jdbc，使用struts和hibernate出问题了都不知道是怎么回事。
struts神马的不过是对servlet.filter的封装而已,hibernate神马的也不过是对jdbc的封装而已,他们只是把一些常见的操作流程化了,如果不懂servlet.filter,不懂jd ...
- JDBC 详解(转载)
原文链接:http://blog.csdn.net/cai_xingyun/article/details/41482835 什么是JDBC? Java语言访问数据库的一种规范,是一套API JDBC ...
- JDBC详解（转）
原文链接:http://blog.csdn.net/cai_xingyun/article/details/41482835 什么是JDBC? Java语言访问数据库的一种规范,是一套API JDBC ...
- MySQL数据库学习笔记（九）----JDBC的ResultSet接口（查询操作）、PreparedStatement接口重构增删改查（含SQL注入的解释）
[声明] 欢迎转载,但请保留文章原始出处→_→ 生命壹号:http://www.cnblogs.com/smyhvae/ 文章来源:http://www.cnblogs.com/smyhvae/p/4 ...
- Class.forName("com.mysql.jdbc.Driver");的作用
对于大的项目当然我们都已经有了原有基本框架,但是对于一些新的技术探讨的时候,我们还是直接调用Class.forName("com.mysql.jdbc.Driver")连接数据库进 ...
- JDBC 数据库连接池
http://www.cnblogs.com/lihuiyy/archive/2012/02/14/2351768.html JDBC 数据库连接池 小结 当对数据库的访问不是很频繁时,可以在每次 ...
- JDBC详解（汇总）
from:http://www.cnblogs.com/lee/archive/2007/08/25/869656.html:http://blog.csdn.net/lovesomnus/artic ...
- Connection 对象简介 方法解读 JDBC简介（四）
通过驱动管理器DriverManager的getConnection方法,可以创建到指定URL的连接 Connection conn = DriverManager.getConnection ...
- 百战程序员——JDBC
JDBC全称是什么? JDBC(Java DataBase Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Jav ...
随机推荐
- SQL Server 创建索引
索引的简介: 索引分为聚集索引和非聚集索引,数据库中的索引类似于一本书的目录,在一本书中通过目录可以快速找到你想要的信息,而不需要读完全书. 索引主要目的是提高了SQL Server系统的性能,加快数 ...
- thinkphp查询某个字段为空的数据
$where['name'] = ['exp', 'is null']; //为空的 $where['name'] = ['exp', 'is not null']; //不为空的
- java servlet简述
概述 servlet就相当于一个java小程序,其作用主要是为了接收并响应客户端的请求 入门 1.新建工程并新建个类 2.重写servlet的方法(重要的是service方法) 3.部署工程 a.在w ...
- C# Common Log function
public int Log(string info) { info = "-----------------------------" + DateTime.Now.ToStri ...
- Android进阶：七、Retrofit2.0原理解析之最简流程【上】
retrofit 已经流行很久了,它是Square开源的一款优秀的网络框架,这个框架对okhttp进行了封装,让我们使用okhttp做网路请求更加简单.但是光学会使用只是让我们多了一个技能,学习其源码 ...
- HDU - 1827 Summer Holiday (强连通)
<题目链接> 题目大意: 听说lcy帮大家预定了新马泰7日游,Wiskey真是高兴的夜不能寐啊,他想着得快点把这消息告诉大家,虽然他手上有所有人的联系方式,但是一个一个联系过去实在太耗时间 ...
- AutoCAD下载
AutoCAD 2019 64位破解版 附注册机和安装教程 1.71G AutoCAD 2019 64位精简优化版 珊瑚の海简体中文版691.08M
- AngularJS多个ng-app只解析第一个的问题
<div id="1" ng-app="myApp" ng-controller="ctrl"> <table> & ...
- Java String类的intern()方法
该方法的作用是把字符串加载到常量池中(jdk1.6常量池位于方法区,jdk1.7以后常量池位于堆) 在jdk1.6中,该方法把字符串的值复制到常量区,然后返回常量区里这个字符串的值: 在jdk1.7里 ...
- python爬虫实践（一）
最近在学习爬虫,学完后想实践一下,所以现在准备爬取校花网的一部分图片 第一步,导入需要的库 from urllib import request #用于处理request请求和获得响应 from ur ...