• 2024.3.11 - DAY05_JAVA高级

    day05_Java高级

    一、今日课程内容

    • 1- JDBC协议
    • 2- 多线程
    • 3- maven基本介绍

    二、JDBC协议

    2、JDBC入门案例

    2.6 完整的SQL
    1. package com.itheima.jdbc;
    2.  
    3. import java.sql.*;
    4.  
    5. public class Test02_jdbc {
    6.  
    7.     public static void main(String[] args) throws Exception{
    8.         
    9.         // 增
    10.         insert();
    11.         
    12.         // 修
    13.         update();
    14.         
    15.         // 删
    16.         delete();
    17.         
    18.         // 查询
    19.         query();
    20.  
    21.  
    22.     }   
    23.     // 查询多条数据
    24.     private static void query() throws ClassNotFoundException, SQLException {
    25.         //1. 注册驱动
    26.         Class.forName("com.mysql.jdbc.Driver");
    27.         //2. 根据驱动管理器对象 获取 连接对象
    28.         Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
    29.         //3. 根据连接对象 获取SQL语句执行平台
    30.         Statement stat = conn.createStatement();
    31.  
    32.         //4. 执行 SQL
    33.         String sql = "select * from stu where  age > 20";
    34.         ResultSet resultSet = stat.executeQuery(sql);
    35.         //5. 处理结果集
    36.         while(resultSet.next()){
    37.             // 有下一行
    38.             int id = resultSet.getInt("id");
    39.             String name = resultSet.getString("name");
    40.             int age = resultSet.getInt("age");
    41.             String address = resultSet.getString("address");
    42.  
    43.             System.out.println("id:"+id+";name:"+name+";age:"+age+";address:"+address);
    44.         }
    45.  
    46.         //6. 释放资源
    47.         stat.close();
    48.         conn.close();
    49.     }
    50.  
    51.     // 删除数据
    52.     private static void delete() throws ClassNotFoundException, SQLException {
    53.         //1. 注册驱动
    54.         Class.forName("com.mysql.jdbc.Driver");
    55.         //2. 根据驱动管理器对象 获取 连接对象
    56.         Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
    57.         //3. 根据连接对象 获取SQL语句执行平台
    58.         Statement stat = conn.createStatement();
    59.  
    60.         //4. 执行 SQL
    61.         String sql = "delete from stu where address = '广州'";
    62.         int i = stat.executeUpdate(sql);
    63.         //5. 处理结果集
    64.         System.out.println("影响了:"+i);
    65.         //6. 释放资源
    66.         stat.close();
    67.         conn.close();
    68.     }
    69.  
    70.     // 更新操作
    71.     private static void update() throws ClassNotFoundException, SQLException {
    72.         //1. 注册驱动
    73.         Class.forName("com.mysql.jdbc.Driver");
    74.         //2. 根据驱动管理器对象 获取 连接对象
    75.         Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
    76.         //3. 根据连接对象 获取SQL语句执行平台
    77.         Statement stat = conn.createStatement();
    78.  
    79.         //4. 执行 SQL
    80.         String sql = "UPDATE stu set name = '李九' where id = 1";
    81.         int i = stat.executeUpdate(sql);
    82.         //5. 处理结果集
    83.         System.out.println("影响了:"+i);
    84.         //6. 释放资源
    85.         stat.close();
    86.         conn.close();
    87.     }
    88.  
    89.     // 添加数据
    90.     private static void insert() throws ClassNotFoundException, SQLException {
    91.         //1. 注册驱动
    92.         Class.forName("com.mysql.jdbc.Driver");
    93.         //2. 根据驱动管理器对象 获取 连接对象
    94.         Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
    95.         //3. 根据连接对象 获取SQL语句执行平台
    96.         Statement stat = conn.createStatement();
    97.  
    98.         //4. 执行 SQL
    99.         String sql = "insert into stu values(6,'周八',29,'广州')";
    100.         int i = stat.executeUpdate(sql);
    101.         //5. 处理结果集
    102.         System.out.println("影响了:"+i);
    103.         //6. 释放资源
    104.         stat.close();
    105.         conn.close();
    106.     }
    107. }

    3、SQL注入的问题

    SQL注入：用户输入的内容作为了SQL语句语法的一部分，改变了原有SQL真正的意义。

    假设有登录SQL语句如下:

    SELECT * FROM 用户表 WHERE NAME = 用户输入的用户名 AND PASSWORD = 用户输的密码;

    此时，当用户输入正确的账号与密码后，查询到了信息则让用户登录。但是当用户输入的账号为XXX 密码为：XXX’ OR ‘a’=’a时，则真正执行的代码变为：

    SELECT * FROM 用户表 WHERE NAME = ‘XXX’ AND PASSWORD =’ XXX’ OR ’a’=’a’;

    此时，上述查询语句时永远可以查询出结果的。那么用户就直接登录成功了，显然我们不希望看到这样的结果，这便是SQL注入问题。 为此，我们使用PreparedStatement来解决对应的问题。

    3.1 预处理对象

    preparedStatement：预编译对象，是Statement对象的子类。

    特点:

    • 性能高
    • 会把SQL语句先编译
    • 能过滤掉用户输入的关键词

    使用说明:

    1. PreparedStatement预处理对象，处理的每条sql语句中所有的实际参数，都必须使用占位符?替换。
    2.  
    3. String sql = "select * from user where username = ? and password = ? ";
    4. 	
    5. PreparedStatement使用，需要通过以下3步骤完成：
    6. 	1.PreparedStatement预处理对象代码:
    7. 		// 获得预处理对象，需要提供已经使用占位符处理后的SQL语句
    8. 		PreparedStatement psmt = conn.prepareStatement(sql)
    9. 	2.设置实际参数
    10. 		void setXxx(int index, Xxx xx) 将指定参数设置指定类型的值
    11. 			参数1: index 实际参数序列号，从1开始。
    12. 			参数2: xxx 实际参数值，xxx表示具体的类型。
    13. 		例如：
    14. 			setString(2, "1234") 把SQL语句中第2个位置的占位符?替换成实际参数 "1234"
    15. 	3.执行SQL语句
    16. 		int executeUpdate(): --执行insert update delete语句.
    17. 		ResultSet executeQuery(): --执行select语句.
    18. 		boolean execute(): --执行select返回true 执行其他的语句返回false.

    3.2 基于预处理完成相关的操作
    1. package com.itheima.jdbc;
    2.  
    3. import java.sql.*;
    4. import java.util.Scanner;
    5. /*
    6.     create database day05_jdbc char set utf8;
    7.     use day05_jdbc;
    8.  
    9.     create table `user`(
    10.         id int primary key,
    11.         username varchar(20),
    12.         password varchar(20)
    13.     );
    14.  
    15.     insert into `user` values(1,'zhangsan','123');
    16.     insert into `user` values(2,'lisi','456');
    17.     insert into `user` values(3,'wangwu','789');
    18.  */
    19. public class Demo01_JDBC_Login {
    20.     private static Connection conn;
    21.  
    22.  
    23.     static{
    24.         try {
    25.             // 3.1 注册驱动
    26.             Class.forName("com.mysql.jdbc.Driver");
    27.  
    28.             // 3.2 根据连接管理器对象, 创建连接对象
    29.             conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
    30.  
    31.  
    32.         }catch (Exception e){
    33.             e.printStackTrace();
    34.         }
    35.     }
    36.  
    37.     public static void main(String[] args) throws Exception {
    38.  
    39.         //1. 创建键盘录入的对象
    40.         Scanner scanner = new Scanner(System.in);
    41.  
    42.  
    43.         while(true){
    44.             //2. 接收键盘录入的用户和密码
    45.             System.out.print("请输入用户名:");
    46.             String userName = scanner.next();
    47.  
    48.             System.out.print("请输入密码:");
    49.             String password = scanner.next();
    50.             System.out.println(password);
    51.             //3. 根据用户输入的用户名和密码 到数据库中比对
    52.  
    53.             // 3.3 根据连接对象, 创建SQL语句的执行平台
    54.             String sql = "select  * from `user` where username = ? and password = ?";
    55.             PreparedStatement stat = conn.prepareStatement(sql);
    56.  
    57.             // 3.4 执行SQL语句
    58.             // 3.4.1 先对 ? 进行赋值
    59.             stat.setString(1,userName);
    60.             stat.setString(2,password);
    61.             // 3.4.2 执行SQL
    62.             ResultSet rs = stat.executeQuery();
    63.  
    64.             // 3.5 处理结果集
    65.             boolean flag = rs.next();
    66.             if (flag) {
    67.                 System.out.println("恭喜您, 登录成功了......");
    68.                 break;
    69.             }else{
    70.                 System.out.println("您好, 您输入的用户名或密码有误. 请重新输入....");
    71.             }
    72.  
    73.             rs.close();
    74.             stat.close();
    75.         }
    76.  
    77.         // 3.6 释放资源
    78.         conn.close();
    79.  
    80.  
    81.     }
    82. }
    83.

    添加数据

    1. package com.itheima.jdbc;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.DriverManager;
    5. import java.sql.PreparedStatement;
    6.  
    7. public class Demo02_JDBC_Insert {
    8.  
    9.     public static void main(String[] args) throws Exception {
    10.         //1. 注册驱动
    11.         Class.forName("com.mysql.jdbc.Driver");
    12.  
    13.         //2. 根据连接管理器, 创建连接对象
    14.         Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
    15.  
    16.         //3. 根据连接对象, 创建SQL语句的执行平台(预编译)
    17.         String sql = "insert into `user` values(?,?,?)";
    18.         PreparedStatement stat = conn.prepareStatement(sql);
    19.  
    20.         //4. 执行SQL语句
    21.         // 4.1 为 ? 赋值
    22.         stat.setInt(1,4);
    23.         stat.setString(2,"zhaoliu");
    24.         stat.setString(3,"147");
    25.  
    26.         // 4.2 执行SQL
    27.         int i = stat.executeUpdate();
    28.  
    29.         //5 处理结果集
    30.         System.out.println("影响了:"+ i);
    31.  
    32.         //6. 释放资源
    33.         stat.close();
    34.         conn.close();
    35.     }
    36. }
    37.

    4、连接池相关内容

    4.1连接池原理

    连接池理解为存放多个连接的集合。

    image-20221024005412778

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

    Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！

    常见的连接池：C3P0、DRUID。

    4.2 C3P0连接池工具类实现

    C3P0开源免费的连接池！目前使用它的开源项目有：Spring、Hibernate等。使用C3P0连接池需要导入jar包，c3p0使用时还需要添加配置文件“c3p0-config.xml”

    使用步骤:

    • 1- 将C3P0的jar包, 添加到当前项目的lib目录中, 并且设置到开发环境中

    1681005845396

    1681005863450

    • 2- 添加C3P0的配置文件

      • 注意: 配置文件必须放置在SRC的根目录下, 否则无法自动加载到的

    1681005950603

    • 3- 修改配置文件

    1681006232637

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <c3p0-config>
    3. 	<default-config>
    4. 		<property name="driverClass">com.mysql.jdbc.Driver</property>
    5. 		<property name="jdbcUrl">jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&amp;characterEncoding=utf8</property>
    6. 		<property name="user">root</property>
    7. 		<property name="password">123456</property>
    8. 		
    9. 		<property name="initialPoolSize">5</property>
    10. 		<property name="minPoolSize">5</property>
    11. 		<property name="maxPoolSize">20</property>
    12. 	</default-config>
    • 4- 编写代码, 测试连接池如何使用
    1. package com.itheima.jdbc;
    2.  
    3. import com.mchange.v2.c3p0.ComboPooledDataSource;
    4.  
    5. import java.sql.Connection;
    6. import java.sql.PreparedStatement;
    7. import java.sql.ResultSet;
    8.  
    9. public class Test05_连接池使用 {
    10.     public static void main(String[] args) throws Exception {
    11.  
    12.         //1.创建连接池对象
    13.         ComboPooledDataSource dataSource = new ComboPooledDataSource(); // 当创建这个连接池的时候, 自动到src目录下加载 C3P0的配置文件
    14.         //2. 从连接池中获取连接
    15.         Connection conn = dataSource.getConnection();
    16.         //3. 获取SQL语句的执行平台
    17.         String sql = "select  * from user ";
    18.         PreparedStatement stat = conn.prepareStatement(sql);
    19.         //4. 执行SQL
    20.         ResultSet rs = stat.executeQuery();
    21.         //5. 处理结果集
    22.  
    23.         while(rs.next()){
    24.             int id = rs.getInt("id");
    25.             String name = rs.getString("name");
    26.  
    27.             System.out.println("id:"+id +";name:"+name);
    28.         }
    29.  
    30.         //6. 释放步骤
    31.         rs.close();
    32.         stat.close();
    33.         conn.close(); // 此操作并不会关闭连接, 而是归还给连接池
    34.  
    35.     }
    36. }
    37.

    在实际使用中, 肯定不是这样来使用的, 这样每次都需要我们自己来创建连接池, 显然是不合适的, 我们程序更多做的是直接从连接池获取连接对象即可

    解决方案: 构建连接池的工具类, 程序直接基于工具类获取连接

    1. package com.itheima.jdbc;
    2.  
    3. import com.mchange.v2.c3p0.ComboPooledDataSource;
    4.  
    5. import java.sql.Connection;
    6. import java.sql.ResultSet;
    7. import java.sql.Statement;
    8.  
    9. public class C3P0Utils {
    10.  
    11.     private C3P0Utils() {
    12.     }
    13.     //1.创建连接池对象
    14.     private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
    15.  
    16.     // 获取连接
    17.     public static Connection getConnection() throws Exception{
    18.  
    19.         return dataSource.getConnection();
    20.  
    21.     }
    22.  
    23.     //释放资源
    24.     public static void close(ResultSet rs,Statement stat,Connection conn) throws Exception{
    25.         rs.close();
    26.         stat.close();
    27.         conn.close();
    28.  
    29.     }
    30.  
    31.     public static void close(Statement stat,Connection conn) throws Exception{
    32.         stat.close();
    33.         conn.close();
    34.     }
    35.  
    36. }
    37.

    测试工具类

    1. package com.itheima.jdbc;
    2.  
    3. import com.mchange.v2.c3p0.ComboPooledDataSource;
    4.  
    5. import java.sql.Connection;
    6. import java.sql.PreparedStatement;
    7. import java.sql.ResultSet;
    8.  
    9. public class Test06_连接池工具类使用 {
    10.     public static void main(String[] args) throws Exception {
    11.         //1. 从连接池中获取连接
    12.         Connection conn = C3P0Utils.getConnection();
    13.         //2. 获取SQL语句的执行平台
    14.         String sql = "select  * from user ";
    15.         PreparedStatement stat = conn.prepareStatement(sql);
    16.         //3. 执行SQL
    17.         ResultSet rs = stat.executeQuery();
    18.         //4. 处理结果集
    19.  
    20.         while(rs.next()){
    21.             int id = rs.getInt("id");
    22.             String name = rs.getString("name");
    23.  
    24.             System.out.println("id:"+id +";name:"+name);
    25.         }
    26.         //5. 释放步骤
    27.        C3P0Utils.close(rs,stat,conn);
    28.  
    29.     }
    30. }
    31.

    作业

    1- 使用JDBC来完成对数据库表的CURD操作, 要求采用预编译的方式

    2- 尝试构建C3P0Utils的工具类, 并测试使用

    三、多线程(了解)

    我们在之前，学习的程序在没有跳转语句的前提下，都是由上至下依次执行，那现在想要设计一个程序，边打游戏边听歌，怎么设计？

    要解决上述问题,咱们得使用多进程或者多线程来解决

    1、并发与并行

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

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

    image-20221024010758194

    2、线程与进程

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

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

    image-20221024011216617

    image-20221024011245292

    3、创建线程类

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

    1. 1- 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
    2.  
    3. 2- 创建Thread子类的实例，即创建了线程对象
    4.  
    5. 3- 调用线程对象的start()方法来启动该线程

    操作:

    1. package com.itheima.thread;
    2.  
    3. public class MyThread extends Thread {
    4.  
    5.     public MyThread() {
    6.     }
    7.  
    8.     public MyThread(String name) {
    9.         super(name);
    10.     }
    11.  
    12.     @Override
    13.     public void run() {
    14.  
    15.         for (int i = 1; i<=10 ;i++){
    16.             System.out.println("子线程:"+ getName() + "  " +i);
    17.  
    18.             try {
    19.                 Thread.sleep(10);
    20.             } catch (InterruptedException e) {
    21.                 e.printStackTrace();
    22.             }
    23.         }
    24.  
    25.     }
    26. }
    27.  
    28.  
    29. package com.itheima.thread;
    30.  
    31. public class Test01_myThread {
    32.  
    33.     // 多线程的特点:  随机性 和 延迟性
    34.     public static void main(String[] args) throws Exception{ // main 主线程
    35.  
    36.         MyThread myThread = new MyThread("myThread-01"); // 指定线程的名字
    37.         myThread.start(); // 启动子线程
    38.  
    39.  
    40.         for (int i = 1; i<=10 ;i++){
    41.             System.out.println("主线程:"+ Thread.currentThread().getName() + "  " +i);
    42.  
    43.             // 休眠一下
    44.             Thread.sleep(10);
    45.         }
    46.  
    47.  
    48.     }
    49. }
    50.

    Thread类相关方法:

    1. 构造方法:
    2. public Thread():分配一个新的线程对象。
    3. public Thread(String name):分配一个指定名字的新的线程对象。
    4. public Thread(Runnable target):分配一个带有指定目标新的线程对象。
    5. public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。
    6.  
    7. 常用方法:
    8. public String getName():获取当前线程名称。
    9. public void start():导致此线程开始执行; Java虚拟机调用此线程的run方法。
    10. public void run():此线程要执行的任务在此处定义代码。
    11. public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
    12. public static Thread currentThread():返回对当前正在执行的线程对象的引用。

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

    演示接口方式:

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

    代码:

    1. package com.itheima.thread;
    2.  
    3. public class MyRunnable implements Runnable {
    4.     @Override
    5.     public void run() {
    6.         for (int i = 1; i<=10 ;i++){
    7.             System.out.println("子线程:"+ Thread.currentThread().getName() + "  " +i);
    8.  
    9.             try {
    10.                 Thread.sleep(10);
    11.             } catch (InterruptedException e) {
    12.                 e.printStackTrace();
    13.             }
    14.         }
    15.     }
    16. }
    17.  
    18.  
    19. package com.itheima.thread;
    20.  
    21. public class Test02_MyRunnable {
    22.     public static void main(String[] args) throws Exception{
    23.  
    24.         //1. 创建MyRunnable对象
    25.         MyRunnable myRunnable = new MyRunnable();
    26.  
    27.         //2. 创建线程类, 然后将 myRunnable对象 传入线程类中
    28.         Thread thread = new Thread(myRunnable,"myRunnable-0");
    29.  
    30.         //3. 启动线程
    31.         thread.start();
    32.  
    33.         for (int i = 1; i<=10 ;i++){
    34.             System.out.println("主线程:"+ Thread.currentThread().getName() + "  " +i);
    35.  
    36.             // 休眠一下
    37.             Thread.sleep(10);
    38.         }
    39.  
    40.     }
    41. }
    42.

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

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

    四、Maven基本介绍

    image-20221024012022173

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

    Maven的作用:

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

    1、Maven的仓库

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

    image-20221024012216528

    1. 1.maven 自身运行所需要的插件
    2. 2.第三方框架(spring/mybatis/springmvc) 和 工具类的jar包
    3. 3.我们自己开发的maven下那个么安装后的jar包

    2、Maven的坐标

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

    • groupId : 定义当前maven项目名称
    • artifactId: 定义项目模块
    • version : 定义当前项目的当前版本
    1. 示例:
    2. <dependency>
    3.       <groupId>junit</groupId>
    4.       <artifactId>junit</artifactId>
    5.       <version>4.12</version>
    6.       <scope>test</scope>
    7. </dependency>

    3、Maven安装

    image-20221024012551418

    • 2- 安装Maven

      • 将maven压缩包解压, 复制到没有中文没有空格的目录下,即安装完毕

    image-20221024012650887

    • 3- maven的目录介绍

    image-20221024012801553

    • 4- 配置环境变量
    1. MAVEN_HOME=E:\apache-maven-3.2.1
    2.  
    3. Path=%MAVEN_HOME%\bin;... ...

    image-20221024012848881

    1681022819025

    • 5- 配置本地仓库

      • 5.1 将提供好的本地仓库解压放置到一个没有中文没有空格的目录下

      image-20221024111528519

      • 5.2 在maven的配置文件中配置好对应路径
      1. 5.2.1.找到Maven解压目录\conf\settings.xml 
      2. 5.2.2.在setting.xml 文件中找到 localRepository 标签 
      3. 5.2.3.将 <localRepository>/path/to/local/repo</localRepository>从注释中取出 
      4. 5.2.4.将标签体内容修改为自定义的Maven仓库目录
      • 5.3 [可选] 配置阿里云远程仓库
      1. <mirror>
      2.     <id>alimaven</id>
      3.     <name>aliyun maven</name>
      4.     <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
      5.     <mirrorOf>central</mirrorOf>        
      6. </mirror>

      image-20221024013153255

    • 6- 测试maven安装成功

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

    image-20221024111857171

    4、IDEA整合本地Maven

    image-20221024013323389

    image-20221024013339637

    不建议参考上图, 上图为强制配置所谓路径, 建议使用下面的方案, 自动识别远端路径:

    image-20221024112259213

    注意: 上面整体配置是针对全局配置操作, 但是如果你本身以及有了一个IDEA项目, 此项目中配置不会发生改变, 需要手动进行调整

    1681023568184

    1681023621398

    5、IDEA创建maven工程(重点)

    • 1- 创建空的工程

    image-20221024013452168

    image-20221024013506825

    image-20221024013520341

    image-20221024013534841

    • 2- 创建Maven项目

    image-20221024013630406

    image-20221024013653689

    image-20221024114732371

    image-20221024114815232

    image-20221024013735936

    创建后的标准java项目骨架:

    image-20221024013758303

    最完整的maven格式:

    image-20221024120207179

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

    image-20221024115117815

    尝试通过一下方式处理:

    image-20221024115213041

    • 3- 创建Java代码

    image-20221024013833389

    1. package cn.itcast.dao;
    2.  
    3. public class ProductDao {
    4.  
    5.     public void add() {
    6.         System.out.println("--------------------1 ProductDao.add()... ...");
    7.     }
    8.  
    9.     public void del() {
    10.         System.out.println("--------------------2 ProductDao.del()... ...");
    11.     }
    12.  
    13.     public void edit() {
    14.         System.out.println("--------------------3 ProductDao.edit().... ...");
    15.     }
    16.  
    17.     public void query() {
    18.         System.out.println("--------------------4 ProductDao.query()... ...");
    19.     }
    20. }

    6、Junit测试类

    junit是一个专门用于测试的jar包, 通过junit可以实现针对某一个方法直接进行测试, 不需要创建mian方法, 调用方法, 一般通过junit可以实现单元测试, 但是在使用junit时候, 需要满足junnit的使用规范

    • 1- 需要导入Junit的依赖jar包
    1. <!--此标签中, 是专门用于放置相关的依赖包-->
    2.     <dependencies>
    3.         <dependency>
    4.             <groupId>junit</groupId>
    5.             <artifactId>junit</artifactId>
    6.             <version>4.12</version>
    7.         </dependency>
    8.  
    9.     </dependencies>

    1681024714610

    • 2- 可以在代码中使用junit
    1. package com.itheima;
    2.  
    3. import org.junit.After;
    4. import org.junit.Before;
    5. import org.junit.Test;
    6.  
    7. public class Demo02_test {
    8.  
    9.     /*
    10.         @Test 注解   只需要给需要执行测试的方法, 添加上此注解, 那么直接运行当前这个方法进行测试了
    11.             使用前提:
    12.                 1- 测试的方法不能有返回值
    13.                 2- 测试的方法必须是公共的(必须被public所修饰)
    14.                 3- 测试的方法不能有形参
    15.                 4- 测试的方法不能被static修饰
    16. `       @Before: 在@Test 方法执行前自动触发执行
    17.             注意 方法被@Before注解添加上, 此方法必须满足与@Test 一直的前提要求
    18.             作用: 通过@Before 可以设置一些初始化的操作
    19.             
    20.             支持添加多个, 添加后, 执行顺序 从后往前 , 但是一般只需要添加一个
    21.         @After: 在@Test 方法执行后自动触发执行
    22.             注意 方法被@After注解添加上, 此方法必须满足与@Test 一直的前提要求
    23.  
    24.             作用:  当执行完成测试方法后, 相关的关闭资源的操作, 可以放置被@After标注的方法中
    25.             
    26.             支持添加多个. 添加后, 执行顺序 从前往后, 但是一般只需要添加一个
    27.      */
    29.     @Before
    30.     public void before1(){
    31.         System.out.println("我是before1方法.....");
    32.     }
    33.     @Before
    34.     public void before2(){
    35.         System.out.println("我是before2方法.....");
    36.     }
    37.  
    38.     @After
    39.     public void after1(){
    40.         System.out.println("我是after1方法.....");
    41.     }
    42.     @After
    43.     public void after2(){
    44.         System.out.println("我是after2方法.....");
    45.     }
    46.  
    47.     // 单元测试
    48.     @Test
    49.     public void test(){
    50.         test01_add("张三");
    51.     }
    52.  
    53.     public void test01_add(String name){
    54.         System.out.println("添加数据"+name);
    55.     }
    56.     @Test
    57.     public void test01_update(){
    58.         System.out.println("添加数据");
    59.     }
    60.     @Test
    61.     public void test01_delete(){
    62.         System.out.println("添加数据");
    63.     }
    64.  
    65. }
    66.

    7、Maven的常用命令

    image-20221024150346128

    • clean命令

    image-20221024014158918

    • compile命令

    image-20221024014228789

    • test命令

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

    image-20221024014349817

    image-20221024014402529

    • package命令

      • mvn package, 打包项目

    image-20221024014440653

    打包后的项目会在target目录下找到:

    image-20221024014504599

    • install命令

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

    image-20221024014535615

    安装完毕后,可以在本地仓库中找到 对应的项目:

    image-20221024014559022

    注意: 所有的命令操作,都可以直接点击对应的命令来执行

    8、Maven插件管理

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

    • JDK编译版本的插件
    1. <build>
    2.     <plugins>
    3.         <!-- java编译插件 -->
    4.         <plugin>
    5.             <groupId>org.apache.maven.plugins</groupId>
    6.             <artifactId>maven-compiler-plugin</artifactId>
    7.             <version>3.2</version>
    8.             <configuration>
    9.                 <source>1.8</source>
    10.                 <target>1.8</target>
    11.                 <encoding>UTF-8</encoding>
    12.             </configuration>
    13.         </plugin>
    14.     </plugins>
    15. </build>

    9、依赖范围

    image-20221024014927807

    • 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

    1. 总结说明: 
    2. 	当代码写在test目录下的时候, 代码仅做测试使用, 此时建议相关测试使用jar包, 设置为 test
    3. 	当代码在编译的时候, 需要用到jar包里面的内容, 但是运行的时候, 由于运行环境已经存在相关jar包, 此时建议 Provided
    4. 	当代码在编译的时候, 需要使用当前jar包内容, 在运行的时候, 同样依然要使用当前jar包内容, 建议使用 compile
    5. 	当代码在编译的时候, 不需要这个jar包任何内容, 但是运行的时候, 需要使用jar包中相关嘞, 此时建议使用 runtime
    6.  
    7. 默认为: compile
    8.  
    9. 设置方式: 
    10. <dependency>
    11.     <groupId>junit</groupId>
    12.     <artifactId>junit</artifactId>
    13.     <version>4.12</version>
    14.     <!-- 设置依赖范围 -->
    15.     <scope>provided</scope>
    16. </dependency>
    17.  
    18.  
    19. 一般仅需要设置 provided, 当对当前项目进行打包的时候, 如果不需要将某些jar包打包到整个项目的jar包中, 此时设置此范围

    10、聚合工程

    image-20221024163657735

    构建聚合工程:

    • 先创建父工程:

    image-20221024163738569

    image-20221024163818810

    image-20221024163942839

    image-20221024164018826

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

    image-20221024164113318

    • 2- 创建子工程

    image-20221024164214952

    image-20221024164245273

    image-20221024164407276

    image-20221024164508944

    image-20221024164608980

    image-20221024164636040

    同样安装这个方式, 创建更多的子工程:

    有啥用呢?

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

    image-20221024165105674

    image-20221024165317599

    • 3- 父工程聚合所有的子工程, 便于后续的统一管理操作

    • 4- 父工程中多个子工程之间, 可以互相依赖,

      • 比如说 购物车模块需要应用 用户模块的内容

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

    image-20221024165808591

  • 相关阅读:
    学的Java要去 IT 外包公司？
    CCAA 认证通用基础卷之（一）合格评定基础 第二章合格评定与国家质量基础设施 NQI （National Quality Infrastructure）
    推荐三款良心实用软件，让人心动
    Tensorflow基础 Tensorflow基本操作（三）
    两日总结十
    Jquery-todolist案例
    什么是域名？如何注册域名？
    排序——直接插入排序&&折半插入排序
    java虚拟机垃圾回收相关概念
    Mysql8.x版本主从加读写分离（一） mysql8.x读写分离
  • 原文地址：https://blog.csdn.net/m0_49956154/article/details/136637933