【mysql】JDBC高级封装和数据库连接池

最新推荐文章于 2022-08-24 20:43:09 发布
最新推荐文章于 2022-08-24 20:43:09 发布
阅读量267 收藏
点赞数
分类专栏： # Mysql 文章标签： 后端 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43410878/article/details/123819394
版权

文章目录

JDBC高级封装和数据库连接池

1. JDBC高级封装

在这里插入图片描述

1.1 JDBC通用查询方法
方法分析:
	权限修饰符:
		public
	是否静态:
		不需要static修饰
    返回值类型:
    	1. 一定带有泛型
    	2. 数据量不确定
    		List<T>
    方法名:
    	query
    形式参数列表:
    	1. String sql 对应的DQL语句
    	2. 对应当前查询SQL语句的参数
    	3. Class<T> cls
    	(String sql, Class<T> cls, Object... parameters);
	情况分析：
 		当前操作是一个查询方法，我们期望可以从数据库中，数据行 ==> Java中指定数
		据类型的类对象。
		a. 需要告知方法，这里查询的类型是哪一个类型
			类型需要满足多样性，又需要满足数据类型类型一致化
			存在使用泛型的期望。
		b. 在方法中，需要按照用户指定的数据类型，来创建对应的类对象。
			1. new + 构造方法 局限性过大！！！不合适
			2. 通过反射获取Constructor对象，借助于newInstance方法创建。
				存在操作的空间！！！
		需要
			1. 泛型
			2. 反射的万恶之源 Class
		Class<T> cls
        例如:
			Person.class ==> 
				cls ==> Person类
				<T> ==> <Person>

方法声明:
	public <T> List<T> query(String sql, Class<T> cls, Object... parameters);

对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping）
【补充知识点 BeanUtils】
第三方Jar包，用于提供操作符合JavaBeans类对象一些统一化操作方式。
	1. 赋值成员变量
		setProperty
	2. 取值成员变量
		getProperty
	3. 拷贝类对象
		copyProperties
	4. Map双边队列转类对象。

对应Jar包
	commons-beanutils-1.8.3.jar
	commons-logging-1.1.3.jar
	需要使用beanutils，必须有对应的logging Jar包。必要依赖关系！！！
	
	Maven
		==> pom.xml

package com.qfedu.b_beanutils;

import org.apache.commons.beanutils.BeanUtils;

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;

public class Demo1 {
    public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        Person person = new Person();
        Person person1 = new Person();

        /*
        public static void setProperty(Object bean, String name, Object value)
        bean 是符合JavaBean规范的类对象
        name 指定赋值的成员变量名字
        value 对应当前成员变量名字的数据
         */
        BeanUtils.setProperty(person, "id", 1);
        BeanUtils.setProperty(person, "name", "苟磊");
        BeanUtils.setProperty(person, "age", 16);
        System.out.println(person);

        System.out.println();
        /*
        public static String getProperty(Object bean, String name);
        bean 符合JavaBean规范的类对象
        name 对应的需要获取数据成员变量名字
        returnType String 对应数据String类型
         */
        String id = BeanUtils.getProperty(person, "id");
        String name = BeanUtils.getProperty(person, "name");
        String age = BeanUtils.getProperty(person, "age");
        System.out.println(id);
        System.out.println(name);
        System.out.println(age);

        System.out.println();

        System.out.println(person1);
        /*
        public static void copyProperties(Object dest, Object orig)
        dest 目标类对象，要求符合JavaBean规范
        orig 源数据类型对象，要求符合JavaBean规范
         */
        BeanUtils.copyProperties(person1, person);
        System.out.println(person1);

        HashMap<String, String> map = new HashMap<>();

        map.put("id", "123");
        map.put("gender", "男");
        map.put("name", "骚磊");
        map.put("salary", "20");
        map.put("age", "6");


        /*
        public static void populate(Object bean, Map properties)
        bean 符合Javabeans规范的类对象
        properties Map双边队列类型 Key=Value
         */
        BeanUtils.populate(person1, map);
        System.out.println(person1);

    }
}
2. JDBC封装完成项目数据持久化操作
student类
package com.zx.studentsystem.entity;

public class Student {
    private int id;
    private String name;
    private int age ;
    private boolean gender;
    private int score;

    public Student() {
    }

    public Student(String name, int age, boolean gender, int score) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.score = score;
    }

    public Student(int id, String name, int age, boolean gender, int score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.score = score;
    }

    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 boolean isGender() {
        return gender;
    }

    public void setGender(boolean gender) {
        this.gender = gender;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }


    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                ", score=" + score +
                '}';
    }
}
数据库端
package com.zx.studentsystem.dao;

import com.zx.studentsystem.entity.Student;

import java.util.List;

/**
 * StudentDao接口，是Student数据持久化层接口
 * 用于规范关于Student类对象操作数据库的方式方法
 */
public interface StudentDao {

    /**
     * 添加学生对象到当前数据库中保存对应数据
     *
     * @param student Student类对象
     * @return 当前SQL语句操作对应数据库的影响行数
     */
    int addStudent(Student student);


    /**
     * 根据id删除指定Student类对象
     *
     * @param id 用户指定id号
     * @return 当前SQL语句操作对应数据库的影响行数
     */
    int deleteStudent(int id);


    /**
     * 更新对应学生的数据库信息
     *
     * @param student Student类对象
     * @return 当前SQL语句操作对应数据库的影响行数
     */
    int updateStudent(Student student);


    /**
     * 找到对应id号的Student类对象
     *
     * @param id 用户指定id号
     * @return 找到返回Student类对象，未找到返回null
     */
    Student findStudent(int id);


    /**
     * 找到当前数据库中的所有学生对象list集合
     *
     * @return list集合，包含所有的Student类对象，如果当前数据库中数据行为空
     * 返回null
     */
    List<Student> findAll();
}
数据库端实现
package com.zx.studentsystem.dao.impl;

import com.zx.studentsystem.dao.StudentDao;
import com.zx.studentsystem.entity.Student;
import com.zx.studentsystem.util.BaseDao;

import java.util.List;

/**
 * StudentDaoImpl 数据持久化操作的实现类
 */
public class StudentDaoImpl extends BaseDao implements StudentDao {
    @Override
    public int addStudent(Student student) {
        String sql = "insert into mysql2005.student(name, age, gender, score) values (?, ?, ?, ?)";
        Object[] parameters = {student.getName(), student.getAge(), student.isGender(), student.getScore()};

        return super.update(sql, parameters);
    }

    @Override
    public int deleteStudent(int id) {
        String sql = "delete from mysql2005.student where id =" + id;
        return super.update(sql);
    }

    @Override
    public int updateStudent(Student student) {

        String sql = "update mysql2005.student set name = ?, age = ?, gender = ?, score = ? where  id = ?";
        Object[] parameters = {student.getName(), student.getAge(), student.isGender(), student.getScore(), student.getId()};

        return super.update(sql, parameters);
    }

    @Override
    public Student findStudent(int id) {
        String sql = "select * from mysql2005.student where id =" + id;
        List<Student> list = super.query(sql, Student.class);
        return list != null ? list.get(0) : null;
    }

    @Override
    public List<Student> findAll() {
        String sql = "select * from mysql2005.student";
        return super.query(sql, Student.class);
    }
}
服务端
package com.zx.studentsystem.service;

/**
 * 对外提供关于Student操作服务
 *      增加学生
 *      开除学生
 *      查询指定id学生
 *      修改学生信息
 *      查询所有学生
 *      按照指定条件过滤学生
 *      按照指定条件排序学生
 */
public interface StudentService {
    /**
     * 添加学生
     */
    void addStudent();

    /**
     * 开除学生
     */
    void removeStudent();

    /**
     * 查询指定学生
     */
    void findOneStudent();


    /**
     * 修改指定学生
     */
    void modifyStudent();


    /**
     * 查询所有学生
     */
    void  findAllStudent();


    /**
     * 过滤条件展示学生信息
     */
    void filterStudent();


    /**
     * 按照指定条件展示学生信息
     */
    void sortStudent();
}
服务端实现
package com.zx.studentsystem.service.Impl;

import com.zx.studentsystem.dao.StudentDao;
import com.zx.studentsystem.dao.impl.StudentDaoImpl;
import com.zx.studentsystem.entity.Student;
import com.zx.studentsystem.service.StudentService;

import java.util.List;
import java.util.Scanner;

public class StudentServiceImpl implements StudentService {

    /**
     * 当前StudentServiceImpl实现类中需要操作数据库持久操作
     * 这里需要StudentDao实现类支持
     */

    private StudentDao studentDao = new StudentDaoImpl();
    private static Scanner sc = new Scanner(System.in);

    @Override
    public void addStudent() {
        System.out.println("请输入学生的姓名：");
        String name = sc.nextLine();

        System.out.println("请输入学生的年龄：");
        int age = sc.nextInt();

        System.out.println("请输入学生的性别：");
        boolean gender = sc.nextBoolean();

        System.out.println("请输入学生的成绩：");
        int score = sc.nextInt();

        Student student = new Student(name, age, gender, score);

        studentDao.addStudent(student);
    }

    @Override
    public void removeStudent() {
        System.out.println("请输入学生的id号：");
        int id = sc.nextInt();

        studentDao.deleteStudent(id);

    }

    @Override
    public void findOneStudent() {

        System.out.println("请输入学生的id号:");
        int id = sc.nextInt();
        System.out.println(studentDao.findStudent(id));
    }

    @Override
    public void modifyStudent() {
        System.out.println("请输入要修改的学生的id号：");
        int id = sc.nextInt();

        sc.nextLine();
        System.out.println("请输入学生的姓名：");
        String name = sc.nextLine();

        System.out.println("请输入学生的年龄：");
        int age = sc.nextInt();

        System.out.println("请输入学生的性别：");
        boolean gender = sc.nextBoolean();

        System.out.println("请输入学生的成绩：");
        int score = sc.nextInt();

        Student student = new Student(id, name, age, gender, score);

        studentDao.updateStudent(student);

    }

    @Override
    public void findAllStudent() {

        List<Student> list = studentDao.findAll();
        if (list != null) {
            for (Student stu : list) {
                System.out.println(stu);
            }
        }
    }

    @Override
    public void filterStudent() {

        List<Student> list = studentDao.findAll();

        if (list != null) {
            System.out.println("1,年龄大于20的");
            System.out.println("2,成绩小于60的");
            int choose = sc.nextInt();

            switch (choose) {
                case 1:
                    list.stream()
                            .filter(s -> s.getAge() > 20)
                            .forEach(System.out::println);
                    break;
                case 2:
                    list.stream()
                            .filter(s -> s.getScore() < 60)
                            .forEach(System.out::println);
                    break;
            }
        }
    }

    @Override
    public void sortStudent() {
        List<Student> list = studentDao.findAll();

        if (list != null) {
            System.out.println("1,年龄升序");
            System.out.println("2,成绩降序");
            int choose = sc.nextInt();

            switch (choose) {
                case 1:
                    list.stream()
                            .sorted((s1, s2) -> s1.getAge() - s2.getAge())
                            .forEach(System.out::println);
                    break;
                case 2:
                    list.stream()
                            .sorted((s1,s2) -> s2.getScore() - s1.getScore())
                            .forEach(System.out::println);
                    break;
            }
        }

    }
}
控制台
package com.zx.studentsystem.controller;

import com.zx.studentsystem.service.Impl.StudentServiceImpl;
import com.zx.studentsystem.service.StudentService;
import com.zx.studentsystem.util.MethodEnum;

import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class StudentController {

    private Scanner sc = new Scanner(System.in);

    /**
     * 提供Student范围，StudentService实现类
     */
    private StudentService service = new StudentServiceImpl();

    public void controller() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

        Map<Integer, String> methodMap = getMethodMap();
        while (true) {
            System.out.println("1.添加学生 addStudent");
            System.out.println("2.开除指定学生 removerStudent");
            System.out.println("3.修改指定学生 modifyStudent");
            System.out.println("4.查询指定学生 findOneStudent");
            System.out.println("5.查询所有学生 findAllStudent");
            System.out.println("6.过滤条件展示学生信息 filterStudent");
            System.out.println("7.按照指定条件展示学生信息 sortStudent");
            System.out.println("8.退出");

            int choose = sc.nextInt();
            sc.nextLine();

            if (8 == choose) {
                break;

                 /*
                choose不得大于8 不得小于等于0，不然无法在map双边队列中获取对应的数据
                 */
            } else if (choose <= 0 || choose > 8) {
                continue;
            }
             /*
            从Map中跟腱对应的choose获取对应MethodName方法名字，从StudentServiceImpl对应Class对象
            中获取对应的方法Method对象，invoke执行操作
             */
            StudentServiceImpl.class.getMethod(methodMap.get(choose)).invoke(service);
        }
    }

    /**
     * 预处理对应的Map方法双边队列
     *
     * @return Integer类型映射String方法名字的Map双边队列
     */
    private  Map<Integer, String> getMethodMap() {
        HashMap<Integer, String> map = new HashMap<>();

        map.put(1,"addStudent");
        map.put(2, "removeStudent");
        map.put(3, "modifyStudent");
        map.put(4, "findOneStudent");
        map.put(5, "findAllStudent");
        map.put(6, "filterStudent");
        map.put(7, "sortStudent");

        return map;
    }

}
主程序函数
package com.zx.studentsystem.mainProject;

import com.zx.studentsystem.controller.StudentController;

import java.lang.reflect.InvocationTargetException;

public class StudentSystem {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        new StudentController().controller();
    }
}
九离⠂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDBC、封装JDBC连接池、第三方连接池工具
程序小白的成长
12-13 397
主要内容：JDBC简介JDBC来源通过代码实现JDBCJDBC的改进需求JDBC改进的代码实现JDBC使用的设计模式封装连接池封装JDBC连接池ThreadLoacl的使用ThreadLocal常见方法第三方连接池工具（数据源）策略模式 JDBC简介 全称：Java DataBase Connection 译名：Java数据库连接 JDBC来源 JDBC的来源： 最早在Java提出连接数据库需求的...
jdbc连接池简单封装
royzhou1985
03-08 129
主要实现方法是: 使用一个容器(LinkedList),初始化的时候设定好连接数,生成Connection对象放在容器中 以后每次获取连接的时候都从容器中获取,但是这样有一个问题,当我们关闭连接的时候调用 Connection的close()方法的时候会直接将Connection关闭而不是重新放到容器中…… 在这里使用的是代理,真正使用的是通过代理生成的一个存放在内存中的类,在这个类拦截了...
基础工具类_JDBC对数据库连接池封装-JDBCUtils
Fhakjfksakln的博客
09-17 158
使用前将properties文件放在web的src文件中 使用的数据库连接池是阿里巴巴提供的druid url=jdbc:mysql:///travel //连接的数据库 默认省略 端口8080 username=root //自己的数据库账户 password=123456 //以及密码 initialSize=5 //初始化提供的连接数量 maxActive=10 //连接池中提供的最大连接数 以实际情况配置 maxWai
JDBC 高级封装
weixin_51313154的博客
06-25 175
java操作数据库，通过封装消除冗余代码，
JDBC 连接池封装
wtuyzh的专栏
05-27 1311
jdbc
封装一个简单的JDBC连接池
Littleofthenew的博客
12-11 249
封装一个简单的JDBC连接池 import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.sql.Connection; import java.sql.SQLException; import java.util.Properties; ...
JDBC类的封装 + 数据库连接池
天堂有路你不走，学海无涯苦作舟
01-09 569
context.xml WEB-INF/web.xml ${catalina.base}/conf/web.xml <Resource name="jdbc/oracles" auth="Container" type="javax.sql.DataSource" maxActive="100" maxIdle="30" maxWait="1000"
JDBC连接池封装（1）
李宸净
07-08 699
回顾：先复习一下JDBC的流程：JDBC六部曲案例：通过jdbc查询表格，并且查看性能问题。 【运行结果】：可以看出创建连接的时长远远慢得多，性能不好。（有一部分是我的电脑性能不大好，时长比你们的更长一些） 由以上代码可以看出的问题有： 1、jdbc的性能不好。（从运行结果可以看到，创建连接的时长太长）----解决的办法JDBC连接池的封装。 2、jdbc代码的冗余。（每次对数据库进行增删改查，都需要写一遍JDBC的流程，会很多余）----解决的办法ORM的封装。（后面单独有orm的笔记）具体代码实现：
JDBC-数据库连接池实现&BaseDao封装
席木木的博客
01-31 1389
JDBC-数据库连接池实现&BaseDao封装连接池连接池原理连接池代码实现BaseDao封装 连接池 连接池原理 ①某次从集合中获取Connection对象时，集合为空，那么就创建一个新的连接对象,并返回； ②为了避免无限制的创建Connection对象，降低内存消耗，可以设置集合中能够存储的连接数上限值； ③如果超过连接池规定的Connection数量上限，就释放掉多余的连接对象。 ※ 在框架阶段的实际开发中，可以使用例如：C3P0、Druid、DBCP等第三方数据库连接池框架实现连接池操作。
Java 封装数据库连接池
qq_48288251的博客
09-07 748
调用 方法 String sql = “update anz set date=? where sid=?”; PreparedStatement pst = jdbc.getConnection1().prepareStatement(sql); Date ad = new Date(); SimpleDateFormat df=new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”); String str=df.format(ad); java.util.Date hi
深入JDBC高级封装
02-20
深入JDBC高级封装,包括jdbc核心机制以及ormaping框架hibernate ,ejb
数据库连接池封装【Java源码】
12-05
说下这几个类的作用 1.SysInfo.xml 这个xml文件，完全就是为程序的一些需要配置的外部信息做准备的，比如你要连接数据库，那么url,用户名，密码都写在里面。当然你要是做的web项目的话，你的这些信息可以完全写在web.xml里面，然后设置一个自启动的servlet每当程序启动的时候就一次性载入这些配置信息就好了。 2.SysInfo.java 这个类，也很简单，利用了jdom这个jar包里别人封装好的dom功能，来读去xml。当然读的就是我的那个Sysinfo.xml了。 3.DBConnPoolMgr.java 这个类就是利用了DBCP包写数据库连接池。 4.ISqlHelper.java 其实这个接口也很简单，定义了那么几个方法，说白了就是操作数据库的，为什么要写成泛型的接口，为了就是后面大家的业务有针对性，一个实体一个业务功能类。 5。SqlHelper.java 这个类最为关键，它肯定是实现了ISqlHepler.java里面的所有的方法。
JDBC高级封装------Connction对象的封装
学习之中
05-31 2853
前言： 在连接数据库的时候，我们往往会发现，有些操作和代码都是一样的，所以，秉承着java的封装的思想，我们可以将其抽调成一个函数。而这里的jdbc技术中，加载驱动类，定义数据库的地址路径、用户名、密码以及创建connection对象每一次使用jdbc技术时，要进行的基础操作。而我们已知一些工具类可以直接调用，如：String、Math等等，它们就是封装了一些常用的方法，以便于开发者调用，提高开发效率。我们这里如果将jdbc中连接数据库、加载驱动类和创建Connection对象这几个步骤分...
[Driver] 德鲁伊数据库连接池封装
沫洺的博客
08-24 314
数据库连接池,配置环境,添加德鲁伊模板
jdbc连接Mysql方法封装
weixin_34273481的博客
08-11 77
package com.shopping.util;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.S...
java dpcp_jdbc结合dpcp连接池的封装实例
weixin_33682804的博客
02-13 297
demo需求：实现jdbc结合dpcp连接池的封装(以oracle数据库为例)并实现简单地查找demo主要技术：(1)Properties类加载.properties的方式(2)dpcp连接池建立数据库连接的方式(3)查询数据的方式(4)静态代码块的使用，分离驱动的加载和连接信息的载入，整个服务器生命周期只执行一次demo所用jar包：classes12.jarcommons-dbcp-1.4.j...
封装JDBC的数据库连接操作以及更新和查询
weixin_52132674的博客
12-13 258
1.声明静态加载元素 public class DButils { /** * 驱动类路径 */ private static final String DRIVER_CLASS = "com.mysql.jdbc.Driver"; /** * URl地址 */ private static final String URL = "jdbc:mysql://localhost:3306/test"; /** * 登
数据库---MYSQL--JDBC高级 封装JDBC实现增删改
weixin_45881192的博客
01-23 208
在database.properties中配置 驱动信息，3个连接信息—url、username、password com.mysql.jdbc.Driver 是 mysql-connector-java 5中的， com.mysql.cj.jdbc.Driver 是 mysql-connector-java 6中的 ①com.mysql.jdbc.Driver 的写法： d...
java jdbc连接池化封装
mr_lili_111的博客
04-06 4839
  /////////jdbc连接操作 private static String url; /** * 用户名 */ private static String userName; /** * 密码 */ private static String password;   private static String driver;   // 连接池 private...
jdbc连接池和数据库连接池
最新发布
10-28
JDBC连接池和数据库连接池是同一个概念，都是为了提高数据库连接的效率和性能而设计的。连接池是一组已经建立好的数据库连接，应用程序可以从连接池中获取连接，使用完毕后再将连接放回连接池中，以便下次使用。这样可以避免频繁地建立和关闭数据库连接，从而提高数据库的访问效率和性能。JDBC连接池的实现主要是对JDBC中几个核心对象Connection、Statement、PreparedStatement、CallableStatement以及ResultSet的封装与动态代理。常见的数据库连接池有C3P0、BoneCP、DBCP、Tomcat Jdbc Pool、Druid和HikariCP等。其中，Druid和HikariCP是目前比较流行的高性能数据库连接池。Druid是阿里巴巴开源的数据库连接池，具有监控、防御SQL注入攻击、支持Oracle、MySql、SqlServer等多种数据库等特点。HikariCP是一个轻量级、高性能的数据库连接池，被广泛应用于Spring Boot等框架中。它的特点是快速、高效、易用、可靠、稳定。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值