【Java温故知新(四)】JDBC优化方案|多线程|Maven

JDBC连接数据库的两种优化方案:

• C3P0连接池

• 防SQL注入(使用preparedStatement预编译)

回顾JDBC

就跟Pymysql差不多,JDBC使用规范步骤 : 6大步.

JDBC规范（掌握四个核心对象）：

• 1 DriverManager:用于注册驱动
• 2 Connection: 表示与数据库创建的连接
• 3 Statement: 操作数据库sql语句的对象
• 4 ResultSet: 结果集或一张虚拟表

• 1, 注册驱动
  • MySQL5.x版本Class.forName("com.mysql.jdbc.Driver");
  • MySQL8.x版本Class.forName("com.mysql.cj.jdbc.Driver");
• 2, 获取连接对象Connection conn = DriverManager.getConnection(url,username,password);
  • 参数1: url路径地址 格式: jdbc:数据库名称://host:port/数据库名
    • MySQL5.x版本jdbc:mysql://local:3306/day04_jdbc
    • MySQL8.x版本"jdbc:mysql:///day01?serverTimezone=UTC&useSSL=false"
      • 注意: 如果是本机的话local:3306也可以不写直接就jdbc:mysql:///day04_jdbc
      • serverTimezone是指定时区
        • UTC世界统一时间
        • GMT格林威治时间
  • 参数2: 用户名
  • 参数3: 密码
• 3, 创建语句执行平台
  • 方式一: Statement stat = conn.createStatement()
  • 方式二: PreparedStatement stat = conn.prepareStatement(String sql) 预编译语句执行平台
• 4, 执行增 删 改
  • 配合方式一使用
    • 判断增删改
      • Boolean stat.execute(sql) 配合方式一 返回false 表示执行增删改 返回true表示执行select
    • 影响行数
      • int executeUpdate(String sql) 配合方式一 返回影响了多少行
  • 配合方式二使用
    • 判断增删改
      • boolean execute() 配合方式二 返回false 表示执行增删改 返回true表示执行select
    • 影响行数
      • int executeUpdate() 配合方式二 返回影响了多少行
    • setXXX(int parameterIndex, Xxx x); Xxx 表示某种数据类型 比如 setInt() 配合方式二
  • 查询操作:
    • ResultSet executeQuery(String sql) ; 返回的结果集 ResultSet(二维表)
• 5, 处理结果集

ResultSet相关的API: 
	boolean next()  ; 用于指向下一行 如果没有下一行了, 返回false
	getXxx('字段名'| 第几列); Xxx 表示数据类型 用于获取对应列的数据

• 6, 释放资源: 把对象中含有close方法的对象,全部关闭, 遵循 从后往前依次关闭

C3P0连接池

使用连接池技术的目的：解决建立数据库连接耗费资源和时间很多的问题，提高性能。

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。

C3P0连接池工具类实现

使用C3P0连接池需要导入jar包，c3p0使用时还需要添加配置文件“c3p0-config.xml”

使用步骤:

添加jar包 

编写配置文件 c3p0-config.xml，放在src中（注：文件名一定不要写错）

编写工具类

• 配置c3p0-config.xml : 必须放置到 src目录下 或者专门加载配置文件的路径下

<c3p0-config>
   <!-- 使用默认的配置读取连接池对象 -->
   <default-config>
     <!--  连接参数 -->
     <property name="driverClass">com.mysql.jdbc.Driver</property>
     <property name="jdbcUrl">jdbc:mysql://localhost:3306/day03</property>
     <property name="user">root</property>
     <property name="password">root</property>

     <!-- 连接池参数 -->
     <property name="initialPoolSize">5</property>
     <property name="maxPoolSize">10</property>
     <property name="checkoutTimeout">2000</property>
     <property name="maxIdleTime">1000</property>
   </default-config>
 </c3p0-config>

说明: c3p0 连接池常用的配置参数说明:

​ initialPoolSize : 初始连接数 刚创建好连接池的时候准备的连接数量

​ maxPoolSize : 最大连接数 连接池中最多可以放多少个连接

​ checkoutTimeout : 最大等待时间 连接池中没有连接时最长等待时间

​ maxIdleTime : 最大空闲回收时间 连接池中的空闲连接多久没有使用就会回收

Demo(测试类)

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Demo02_jdbc_连接池基本使用 {

    public static void main(String[] args) throws Exception {

        //1. 创建连接池对象
        // 当创建这个连接池的时候, 会自动加载配置文件, 根据配置文件信息, 去连接数据库, 并创建多个连接, 放置到连接池中
        DataSource dataSource = new ComboPooledDataSource();

        //2. 获取连接
        Connection conn = dataSource.getConnection();

        //3. 获取语句执行平台
        PreparedStatement stat = conn.prepareStatement("SELECT  * FROM user");

        //4. 执行SQL
        ResultSet resultSet = stat.executeQuery();
        
        //5. 处理结果集
        while(resultSet.next()){
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            String sex = resultSet.getString("sex");
            int age = resultSet.getInt("age");

            System.out.println("id:"+id +";name:"+name +";sex:"+sex +";age:"+age);

        }

        //6. 释放资源
        resultSet.close();
        stat.close();
        conn.close();

    }
}

C3P0工具类

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

public class C3P0Utils {

    private C3P0Utils() {
    }

    private static DataSource dataSource;
    // 静态代码块: 随着类的加载而加载, 一般只会加载一次
    static {
        dataSource = new ComboPooledDataSource();
    }

    // 构建一个方法, 用于获取连接对象
    public static Connection getConn() throws Exception{

        return dataSource.getConnection();
    }
    
    // 构建一个方法, 用于释放资源
    public static void close(Connection conn, Statement stat,ResultSet rs) throws Exception{
        if (rs != null) rs.close();

        if (stat != null) rs.close();

        if (conn != null) rs.close();
        
    }

}

工具类的测试操作:

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class Demo03_jdbc_工具类测试 {

    public static void main(String[] args) throws Exception {
        //1. 从连接池中获取连接对象
        Connection conn = C3P0Utils.getConn();

        //3. 获取语句执行平台
        PreparedStatement stat = conn.prepareStatement("SELECT  * FROM user");

        //4. 执行SQL
        ResultSet resultSet = stat.executeQuery();

        //5. 处理结果集
        while(resultSet.next()){
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            String sex = resultSet.getString("sex");
            int age = resultSet.getInt("age");

            System.out.println("id:"+id +";name:"+name +";sex:"+sex +";age:"+age);

        }

        //6. 释放资源
        C3P0Utils.close(conn,stat,resultSet);
    }
}

多线程

并发与并行

并行：指两个或多个事件在同一时刻发生（同时发生）。

并发：指两个或多个事件在同一个时间段内发生。

线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。

线程：进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

创建线程类(继承Thread方法)

创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式.

Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

1- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。

2- 创建Thread子类的实例，即创建了线程对象

3- 调用线程对象的start()方法来启动该线程

操作:

定义线程类

public class MyThread extends Thread {

    @Override
    public void run() {

        for (int i = 0; i<=10 ; i++){
            System.out.println("线程:"+i);
        }

    }
}

测试类:

public class Demo04_thread_继承thread的测试类 {
    public static void main(String[] args) {
        //1. 创建线程类对象
        MyThread myThread = new MyThread();

        //2. 启动Thread线程
        myThread.start();

        //3. 主线程执行一段代码
        for (int i = 0 ; i<=10 ; i++){
            System.out.println("主线程:"+i);
        }
    }
}


总结说明: 
	多线程执行特点: 随机性 延迟性

Thread类相关方法:

构造方法:
public Thread():分配一个新的线程对象。
public Thread(String name):分配一个指定名字的新的线程对象。
public Thread(Runnable target):分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法:
public String getName():获取当前线程名称。
public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run():此线程要执行的任务在此处定义代码。
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread():返回对当前正在执行的线程对象的引用。

创建线程类(实现Runnable接口方式:)

步骤如下：
	•定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
	•创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
	•调用线程对象的start()方法来启动线程。

实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i<=10 ; i++){
            System.out.println("线程:"+i);
        }
    }
}

测试类:

public class Demo05_thread_实现runnable的测试类 {
    public static void main(String[] args) {
        //1.  创建实现runnable接口实现类对象
        MyRunnable myRunnable = new MyRunnable();

        //2. 创建线程类对象, 并将  runnable实现类对象传入到线程类对象
        Thread thread = new Thread(myRunnable);

        //3. 启动线程:
        thread.start();

        //4. 主线程代码:
        for (int i = 0 ; i<=10 ; i++){
            System.out.println("主线程:"+i);
        }
    }
}

实现Runnable接口比继承Thread优势:

•适合多个相同的程序代码的线程去共享同一个资源。
•可以避免java中的单继承的局限性。
•增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
•线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

Maven

基本介绍

Maven是项目进行模型抽象, 充分运用的面向对象的思想, maven可以通过一小段描述信息来管理项目的构建, 报告和文档的软件项目管理工具。maven除了以程序构建能力为特色之外, 还提供高级项目管理工具。由于maven的缺省规则有较高的可重用性, 所以常常用两三行maven构建脚本就可以构建简单的项目。

Maven的作用:

• 1. maven对项目的第三方构建(jar包)进行统一管理。向工程中加入jar包不要手工从其他地方拷贝, 通过maven定义jar包的坐标,自动从maven仓库中下载到工程中。
• 2. maven提供一套对项目生命周期管理的标准, 开发人员、和测试人员统一使用maven进行项目构建。项目生命周期管理: 编译、测试、打包、部署、运行。
• 3. maven对工程分模块构建,提高开发效率

Maven的仓库

仓库名称	作用
本地仓库	相当于缓存, 工程会从远程仓库(互联网)去下载jar包,将jar包存在本地仓库(在程序员的电脑上)。第二次不需要从远程仓库去下载。先从本地仓库找,如果找不到才会去远程仓库找
中央仓库	就是远程仓库, 仓库中jar由专业团队(maven团队)唯一维护。中央仓库的地址: https://mvnrepository.com/
远程仓库	在公司内部假设一台私服, 其他公司假设一台仓库, 对外公开

Maven的坐标

Maven的一个核心的作用就是管理项目的依赖, 引入我们所需的各种jar包等。 为了能自动化的解析任何一个java构件,maven必须将这些jar包或者其他资源进行唯一标识, 这是管理项目的依赖的基础, 也就是我们要说的坐标。 包括我们自己开发的项目,也是要通过坐标进行唯一标识的, 这样才能在其他项目中进行依赖引用。坐标的定义元素如下:

• groupId : 定义当前maven项目名称
• artifactId: 定义项目模块
• version : 定义当前项目的当前版本

示例:
<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
</dependency>

Maven安装

1配置Maven的环境变量

成功的标识mvn -v能出现版本号

MAC参考:

• https://blog.csdn.net/u011374856/article/details/116648311

• https://blog.csdn.net/weixin_43805744/article/details/128023702

• https://blog.csdn.net/minggeqingchun/article/details/109646798

Windows下就是配置环境变量, 跟MAC差不多的.

2在maven的配置文件中配置好对应路径

• 1.找到Maven解压目录\conf\settings.xml
• 2.在setting.xml 文件中找到 localRepository 标签
• 3.将 <localRepository>/path/to/local/repo</localRepository>从注释中取出
• 4.将标签体内容修改为自定义的Maven仓库目录

3 [可选] 配置阿里云远程仓库

<mirror>
    <id>alimaven</id>
    <name>aliyun maven</name>
    <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
    <mirrorOf>central</mirrorOf>        
</mirror>

测试Maven

开cmd本地控制台, 输入mvn -version

IDEA整合本地Maven

在Settings搜索Maven, 找到下图指定的东西,然后配置Maven的安装位置.

最后就是Maven的Repository的位置了, 这里选择本地仓库, 因为夯哥给了一个9G的本地仓库.

链接🔗: 我给放到阿里云盘了. 分享不了

IDEA创建maven工程(重点)

创建后的标准java项目骨架

最完整的maven格式:

如果发现跟上图不一致, 比如如下:

尝试通过这种方式处理:

Junnit测试类

1 - 导入相关的jar包依赖

<dependencies>
	<!--导入junit包-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

2- 在方法上添加测试注解即可 : @Test

package com.itheima;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class Demo01 {
//    public static void main(String[] args) {
//        System.out.println("xxxxxxxxxxxxxxxxxxxx");
//
//        Demo01 demo01 = new Demo01();
//        demo01.test01();
//        demo01.test02();
//        demo01.test03();
//    }

    /*
        junit: 测试包, 主要可以对方法进行单元测试工作

        junit提供的三个常用的注解:  @Test @Before @After
            @Test: 执行测试操作, 被标记的方法, 可以直接对其运行操作
                使用前提条件:
                    1- 被标记的方法不能有返回值
                    2- 方法必须使用public修饰
                    3- 方法的参数列表必须为空
                    4- 方法不能被static修饰
                在@Before @After 同样适用
            @Before : 表示在测试方法执行之前执行
            @After :  表示在测试方法执行之后执行
            
            其中 @Before @After 可选, 如果有需要可以使用
     */

    @Test
    public  void test01(){
        System.out.println("测试方法1");
    }
    @Before
    public void test02(){
        System.out.println("测试方法2");
    }
    @After
    public void test03(){
        System.out.println("测试方法3");
    }

}

3- 即可点击运行测试即可

Maven的常用命令

mvn package, 打包项目

测试命令: 执行 src/test/java 下junit的测试用例

compile命令: 编译

clean命令: 清除编译产生的target文件

mvn install, 打包后将其安装在本地仓库

Maven插件管理

maven是一个核心引擎, 提供了基本的项目处理能力和建设过程的管理, 以及一系列的插件是用来执行实际建设任务。maven插件可以完成一些特点的功能。例如, 集成jdk插件可以方便的修改项目的编译环境; , 在pom.xml中通过plugin标签引入maven的功能插件

JDK编译版本的插件

<build>
    <plugins>
        <!-- java编译插件 -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.2</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
                <encoding>UTF-8</encoding>
            </configuration>
        </plugin>
    </plugins>
</build>

依赖范围

• compile: 编译、测试、运行, A在编译时依赖B, 并且在测试和运行时也依赖

​ 例如: strus-core、 spring-beans 。 打到war包或jar包

• Provided: 编译、和测试有效, A在编译和测试时需要B

​ 例如: 如果某些包在运行的时候, 所对应的容器内已经有这个jar包, 此时就不需要在将包打入, 只需要让其在编译和测试中有效即可

• runtime: 测试、运行有效

  例如: jdbc驱动包, 在开发代码中针对java接口开发, 编译不用 , 在运行和测试时, 需要通过jdbc驱动包(mysql) 连接数据库, 需要时会打入war

• test: 只是测试有效, 只在单元测试类中用

  • 例如: junit 只需要测试用即可, 不会打到war包

按照依赖强度, 由强到弱来排序:

compile > provided > runtime >test

总结说明: 
	当代码写在test目录下的时候, 代码仅做测试使用, 此时建议相关测试使用jar包, 设置为 test
	当代码在编译的时候, 需要用到jar包里面的内容, 但是运行的时候, 由于运行环境以及存在相关jar包, 此时建议 Provided
	当代码在编译的时候, 需要使用当前jar包内容, 在运行的时候, 同样依然要使用当前jar包内容, 建议使用 compile
	当diam在编译的时候, 不需要这个jar包任何内容, 但是运行的时候, 需要使用jar包中相关嘞, 此时建议使用 runtime

默认为: compile

设置方式: 
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <!-- 设置依赖范围 -->
    <scope>provided</scope>
</dependency>

聚合工程

作用

• 1- 当父工程加载一个依赖的时候, 所有的子工程都会依赖这个jar包, 插件也是一样的
• 2- 父工程可以锁定子工程使用相关jar包的版本

• 3- 父工程聚合所有的子工程, 便于后续的统一管理操作
• 4- 父工程中多个子工程之间, 可以互相依赖,
  • 比如说 购物车模块需要应用 用户模块的内容

可以在购物车模块中加载用户模块的jar包

1先创建父工程:

2由于父工程不写代码, 主要设置公共的依赖关系: 删除src目录

3创建子工程

End