数据库与JDBC工具

数据库：1.索引：索引是提供指向存储在表的指定列中的数据值的指针，后根据指定的排序顺序对这些指针排序。
索引分类：普通索引，唯一性索引，主键索引，全文索引，组合索引
创建索引：create index 索引名 on 表名(列)；
alter table 表名 add index 索引名(列)；
create table 表名（列定义...，index 索引名(列));
create unique index 索引名 on 表名(列);
2.视图：是一个或多个表（或其他视图）导出的表，是一个虚表
创建视图：create view 视图名（列）as select（列）from...;
3.事务：数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。
MySQL数据库只有InnoDB引擎(MyISAM不支持事务)才支持事务。
事务属性（ACID）：原子性（Atomicity），一致性（Consistecy），隔离性（Isolation），持久性（Durability）。
4.存储过程（procedure）：数据库操作语言SQL的可编程性实现。
create procedure 过程名([[IN |OUT |INOUT ]参数名1 类型1,参数名2 类型2...])
begin
【declared】临时变量
--执行体
end
调用存储过程：call 存储过程名();
删除存储过程：drop procedure 过程名；
5.函数：CREATE FUNCTION 函数名(参数列表)

RETURNS 返回值类型

BEGIN

[DECLARE] 临时变量

-- 执行体

RETURN 返回值；

END；

调用函数：select 函数名（参数）；
6.数据库优化。
7.触发器：CREATE TRIGGER 触发器名

trigger_time trigger_event

ON tbl_name

FOR EACH ROW

扫描二维码关注公众号，回复： 2748873 查看本文章

BEGIN

trigger_body

END;

8.数据库设计范式：
1NF：必须保证表中每一列都是原子列，不可再进行分割（每一列只能存在一种数据类型）；
2NF：在第一范式基础上，要求表中的每一列都必须与主键列存在直接依赖关系，不允许存在部分依赖情况(联合主键)；
3NF：在第二大范式基础上，要求表中不允许存在传递依赖，主键列A->决定列B->决定列C.
JDBC技术：1.常用接口与类：- Connection
- Statement&PreparedStatement
- ResultSet
- DriverManager
- SQLException
；
2.六大步骤：1. 加载驱动（JDBC4之后无需手动加载）

2. 获取连接

3. 获取处理sql语句命令对象

4. 执行

5. 处理结果

6. 关闭资源

3.DTO（数据传输对象）与DAO（数据访问对象）；
4.jdbc连接池技术：- Druid-alibaba- DBCP （spring管理连接时推荐）
- C3P0（hibernate推荐）
- Proxool
- Tomcat Pool

JDBC工具：需要jar包druid-1.1.10.jar，mysql-connector-java-5.1.39-bin.jar。

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.Set;

import com.alibaba.druid.pool.DruidDataSource;

/**
 * 通用数据库工具，基于Druid连接池实现
 * 包含以下功能：
 * 1.获取资源
 * 2.关闭资源
 * 3.执行通用更新操作
 * 4.执行通用查询操作
 * 5.执行通用单条
 * @author NIUXUYUAN
 *
 */

public class DBUtils {

	//声明一个Druid连接池对象
		private static DruidDataSource pool ;
		/**数据库连接url地址**/
		private static String url;
		/**账号**/
		private static String username;
		/**密码**/
		private static String password;
		/**初始连接数**/
		private static int initialSize;
		/**最大活动连接数**/
		private static int maxActive;
		/**最小闲置连接数**/
		private static int minIdel;
		/**最大等待时间**/
		private static long maxWait;
//		private static String fileName = "/jdbc.properties";
		
		static {
			init();

		}
		 
		/**
		 * 加载属性文件并读取属性文件内容并将其配置给连接信息
		 * @param propName
		 */
		private static void loadProp() {
//			fileName = propName;
			try {
				//属性文件位于src根目录时，加"/"则不用getClassLoader(),繁殖
				InputStream is = DBUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
				Properties p = new Properties();
				p.load(is);
				
				url = p.getProperty("jdbc.url");
				username = p.getProperty("jdbc.username");
				password = p.getProperty("jdbc.password");
				
				initialSize = Integer.parseInt(p.getProperty("initailSize").trim());
				maxActive = Integer.parseInt(p.getProperty("maxActive").trim());
				minIdel = Integer.parseInt(p.getProperty("minIdel").trim());
				maxWait = Long.parseLong(p.getProperty("maxWait").trim());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		private static void init() {
			pool = new DruidDataSource();
			loadProp();
			pool.setUrl(url);
			pool.setUsername(username);
			pool.setPassword(password);
			//设置连接池中初始连接数
			pool.setInitialSize(initialSize);
			//设置最大连接数
			pool.setMaxActive(maxActive);
			//设置最小闲置连接
			pool.setMinIdle(minIdel);
			//设置最大的等待获取连接时间
			pool.setMaxWait(maxWait);
		}
		
		/**
		 * 获取连接
		 * @return
		 */
		public static Connection getConn() {
			try {
				//容错：若连接池为空或被关闭，则重新初始化一个
				if(pool == null || pool.isClosed()) {
					init();
				}
				return pool.getConnection();
			} catch (SQLException e) {
				e.printStackTrace();
			}
			return null;
		}

		/**
		 * 关闭
		 * @param stmt
		 * @param conn
		 */
	public static void close(Statement stmt, Connection conn) {
		try {
			if (stmt != null) {
				stmt.close();
			}
			if (conn != null) {
				conn.close();
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 封装通用的更新操作，
	 * 
	 * @param sql
	 * @return
	 */
	public static boolean exeUpdate(Connection conn,String sql, Object... obj) {
		PreparedStatement ps = null;
		try {
			conn = getConn();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < obj.length; i++) {
				ps.setObject(i + 1, obj[i]);
			}
			return ps.executeUpdate() > 0;
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			close(ps, null);
		}
		return false;
	}

	/**
	 * 技术参数：泛型、集合框架、反射，JDBC 查询
	 * 
	 * @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<>();
		T obj = null;
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[i]);
			}
			ResultSet rs = ps.executeQuery();
			// 获取查询结果集的元数据（获得列的类型、数量及长度）
			ResultSetMetaData rsmd = rs.getMetaData();
			// 申明一个Map集合，用于临时存储一条数据<key：列名,value：列值>
			Map<String, Object> map = new HashMap<>();
			// 遍历结果集
			while (rs.next()) {
				// 防止缓存上一条数据
				map.clear();
				// 遍历所有的列
				for (int i = 0; i < rsmd.getColumnCount(); i++) {
					// 获取列名
					String cname = rsmd.getColumnLabel(i + 1);
					// 获取列值
					Object value = rs.getObject(cname);
					// 将列名与列值存储到map中
					map.put(cname, value);
				}
				// 利用反射将map中数据注入到java对象中，并将对象存入集合
				if (!map.isEmpty()) {
					// 获得map集合键集
					Set<String> columNames = map.keySet();
					// 创建对象
					obj = t.newInstance();
					for (String colum : columNames) {
						// 根据键获取值
						Object value = map.get(colum);
						if(Objects.nonNull(value)) {
							
							// 获取属性对象
							Field f = t.getDeclaredField(colum);
							// 设置属性为可访问状态
							f.setAccessible(true);
							// 为属性设值
							f.set(obj, value);
						}
					}
					list.add(obj);
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}

		return list;
	}

	/**
	 * 封装返回一个查询结果
	 * 
	 * @param t
	 * @param sql
	 * @param params
	 * @return
	 */
	public static <T> T queryOne(Class<T> t, String sql, Object... params) {
		T obj = null;
		Connection conn = null;
		PreparedStatement ps = null;
		try {
			conn = getConn();
			ps = conn.prepareStatement(sql);
			for (int i = 0; i < params.length; i++) {
				ps.setObject(i + 1, params[i]);
			}
			ResultSet rs = ps.executeQuery();
			ResultSetMetaData rsmd = rs.getMetaData();
			//创建一个实例（必须包含无参构造器）
			obj = t.newInstance();
			//ORM操作（对象关系映射）
			if (rs.next()) {
				for (int i = 0; i < rsmd.getColumnCount(); i++) {
					// 获取列名
					String cname = rsmd.getColumnLabel(i + 1);
					//获取对应列名的列值
					Object value = rs.getObject(cname);
					if(Objects.nonNull(value)) {
						
						//根据列名获取Java类的属性名（要求表中列名与类中属性名保持一致）
						Field f = t.getDeclaredField(cname);
						f.setAccessible(true);
						f.set(obj, value);
					}
				}
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
		return obj;
	}
}

猜你喜欢