day05_Java高级

发布于:2025-03-17 ⋅ 阅读:(12) ⋅ 点赞:(0)

day05_Java高级

一、今日课程内容

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

二、JDBC协议

2、JDBC入门案例

2.5 完整的SQL

主要学习下面这个代码:

package cn.itcast.jdbc;

import java.sql.*;

public class JDBCDemo {
    private static Connection conn = null;
    private static Statement statement = null;

    static{
        try {
            // 1- 注册驱动
            Class.forName("com.mysql.jdbc.Driver");

            // 2- 获取连接对象
            conn = DriverManager.getConnection("jdbc:mysql://node1:3306/insurance?useUnicode=true&characterEncoding=utf8",
                    "root",
                    "123456");

            // 3- 创建SQL语句执行对象
            statement = conn.createStatement();

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
//        insert();
//        update();
//        delete();
        selectBatch();
    }

    private static void insert() throws SQLException {
        try {
            // 4- SQL语句
            // 添加数据
            String insertSQL = "insert into policy_client(user_id,name,income) values ('1111-1111','张三','50000')";

            // 5- 执行SQL语句
            /*
                executeUpdate:可以执行DML语句,增删改都可以执行。返回值类型是int类型,它代表的含义是受影响的数据条数
             */
            int resultNum = statement.executeUpdate(insertSQL);
            System.out.println("受影响的数据条数:" + resultNum);
        } finally {
            // 6- 释放资源
            if (statement != null) {
                statement.close();
                System.out.println("statement被释放了");
            }

            if (conn != null) {
                conn.close();
                System.out.println("conn被释放了");
            }
        }
    }


    public static void update()throws ClassNotFoundException, SQLException{
        try {
            // 4- SQL语句
            // 更新数据
            String updateSQL = "update policy_client set income='2000000' where user_id in ('1111-1111','65-290')";

            // 5- 执行SQL语句
            /*
                executeUpdate:可以执行DML语句,增删改都可以执行。返回值类型是int类型,它代表的含义是受影响的数据条数
             */
            int resultNum = statement.executeUpdate(updateSQL);
            System.out.println("受影响的数据条数:" + resultNum);
        } finally {
            // 6- 释放资源
            if (statement != null) {
                statement.close();
                System.out.println("statement被释放了");
            }

            if (conn != null) {
                conn.close();
                System.out.println("conn被释放了");
            }
        }
    }


    public static void delete()throws ClassNotFoundException, SQLException{
        try {
            // 4- SQL语句
            // 删除数据
            String deleteSQL = "delete from policy_client where user_id in ('1111-1111')";

            // 5- 执行SQL语句
            /*
                executeUpdate:可以执行DML语句,增删改都可以执行。返回值类型是int类型,它代表的含义是受影响的数据条数
             */
            int resultNum = statement.executeUpdate(deleteSQL);
            System.out.println("受影响的数据条数:" + resultNum);
        } finally {
            // 6- 释放资源
            if (statement != null) {
                statement.close();
                System.out.println("statement被释放了");
            }

            if (conn != null) {
                conn.close();
                System.out.println("conn被释放了");
            }
        }
    }


    public static void selectBatch()throws ClassNotFoundException, SQLException{
        ResultSet resultSet = null;
        try {
            // 4- SQL语句
            // 批量查询数据
            String sql = "select * from policy_client limit 3";

            // 5- 执行SQL语句
            resultSet = statement.executeQuery(sql);
            while(resultSet.next()){
                String userid = resultSet.getString("user_id");
                String name = resultSet.getString("name");
                int income = resultSet.getInt("income");
                System.out.println(userid+","+name+","+income);
            }
        } finally {
            // 6- 释放资源
            if(resultSet!=null){
                resultSet.close();
            }

            if (statement != null) {
                statement.close();
                System.out.println("statement被释放了");
            }

            if (conn != null) {
                conn.close();
                System.out.println("conn被释放了");
            }
        }
    }
}
package com.itheima.jdbc;

import java.sql.*;

public class Test02_jdbc {

    public static void main(String[] args) throws Exception{
        
        // 增
        insert();
        
        // 修
        update();
        
        // 删
        delete();
        
        // 查询
        query();


    }   
    // 查询多条数据
    private static void query() throws ClassNotFoundException, SQLException {
        //1. 注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 根据驱动管理器对象 获取 连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
        //3. 根据连接对象 获取SQL语句执行平台
        Statement stat = conn.createStatement();

        //4. 执行 SQL
        String sql = "select * from stu where  age > 20";
        ResultSet resultSet = stat.executeQuery(sql);
        //5. 处理结果集
        while(resultSet.next()){
            // 有下一行
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            int age = resultSet.getInt("age");
            String address = resultSet.getString("address");

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

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

    // 删除数据
    private static void delete() throws ClassNotFoundException, SQLException {
        //1. 注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 根据驱动管理器对象 获取 连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
        //3. 根据连接对象 获取SQL语句执行平台
        Statement stat = conn.createStatement();

        //4. 执行 SQL
        String sql = "delete from stu where address = '广州'";
        int i = stat.executeUpdate(sql);
        //5. 处理结果集
        System.out.println("影响了:"+i);
        //6. 释放资源
        stat.close();
        conn.close();
    }

    // 更新操作
    private static void update() throws ClassNotFoundException, SQLException {
        //1. 注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 根据驱动管理器对象 获取 连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
        //3. 根据连接对象 获取SQL语句执行平台
        Statement stat = conn.createStatement();

        //4. 执行 SQL
        String sql = "UPDATE stu set name = '李九' where id = 1";
        int i = stat.executeUpdate(sql);
        //5. 处理结果集
        System.out.println("影响了:"+i);
        //6. 释放资源
        stat.close();
        conn.close();
    }

    // 添加数据
    private static void insert() throws ClassNotFoundException, SQLException {
        //1. 注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2. 根据驱动管理器对象 获取 连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");
        //3. 根据连接对象 获取SQL语句执行平台
        Statement stat = conn.createStatement();

        //4. 执行 SQL
        String sql = "insert into stu values(6,'周八',29,'广州')";
        int i = stat.executeUpdate(sql);
        //5. 处理结果集
        System.out.println("影响了:"+i);
        //6. 释放资源
        stat.close();
        conn.close();
    }
}

重点掌握的代码:

package com.itheima.day05;

import java.sql.*;
import java.util.Scanner;

public class JDBCDemo {

    private static Statement statement;
    private static Connection conn;

    // 静态代码块:这里不能抛出异常
    static{
        try{
            // 1- 注册驱动。通过反射创建
            Class.forName("com.mysql.jdbc.Driver");

            // 2- 获取数据库连接
            String url = "jdbc:mysql://192.168.88.166:3306/day04_jdbc?useUnicode=true&characterEncoding=utf8&useSSL=false";
            conn = DriverManager.getConnection(url, "root", "123456");

            // 3- 获取SQL执行对象
            statement = conn.createStatement();
        }catch(Exception e){
            e.printStackTrace();
            // throw new RuntimeException();
        }
    }

    public static void main(String[] args) {
        JDBCDemo jdbcDemo = new JDBCDemo();
        Scanner sc = new Scanner(System.in);

        in:while(true){
            System.out.println("请输入操作选项1新增,2删除,3修改,4查询,5停止操作:");
            int inputOption = sc.nextInt();

            switch (inputOption){
                case 1:
                    System.out.println("请输入新用户ID:");
                    int insertUserId = sc.nextInt();
                    jdbcDemo.insert(insertUserId);
                    break;

                case 2:
                    System.out.println("请输入要删除的用户ID:");
                    int deleteUserId = sc.nextInt();
                    jdbcDemo.delete(deleteUserId);
                    break;

                case 3:
                    System.out.println("请输入要更新的用户ID:");
                    int updateUserId = sc.nextInt();
                    jdbcDemo.update(updateUserId);
                    break;

                case 4:
                    System.out.println("请输入要查询的用户ID:");
                    int queryUserId = sc.nextInt();

                    System.out.println("请输入要查询的用户姓名:");
                    String queryUserName = sc.next();

                    jdbcDemo.query(queryUserId,queryUserName);
                    break;

                case 5:
                    break in;

                default:
                    System.out.println("您输入的选项有误,"+inputOption);
                    break;
            }
        }
    }

    public void insert(int id) {
        try{
            // 执行插入语句
            String sql = "insert into stu (id,name,age,address) values("+id+",'王六',22,'深圳')";
            // 表示影响的数据条数
            int result = statement.executeUpdate(sql);
            System.out.println(result);
        }catch (Exception e){
            e.printStackTrace();
            // 实际在工作中需要将异常输出到日志文件
        }
    }

    public void delete(int id){
        try{
            // 执行删除语句
            String sql = "delete from stu where id="+id;
            // 表示影响的数据条数
            int result = statement.executeUpdate(sql);
            System.out.println(result);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void update(int id){
        try{
            // 执行删除语句
            String sql = "update stu set name='周三',age=99 where id="+id;
            // 表示影响的数据条数
            int result = statement.executeUpdate(sql);
            System.out.println(result);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void query(int id, String name){
        ResultSet rs = null;
        try{
            String sql = "select * from stu where id="+id+" and name='"+name+"'";
            rs = statement.executeQuery(sql);
            System.out.println(rs);

            // 5- 处理返回结果
            while (rs.next()){
                int age = rs.getInt("age");
                String address = rs.getString("address");
                System.out.println(age+","+address);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 释放资源
            try {
                if(rs != null){
                    rs.close();
                }
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

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语句先编译

  • 能过滤掉用户输入的关键词

使用说明:

PreparedStatement预处理对象,处理的每条sql语句中所有的实际参数,都必须使用占位符?替换。

String sql = "select * from user where username = ? and password = ? ";
	
PreparedStatement使用,需要通过以下3步骤完成:
	1.PreparedStatement预处理对象代码:
		// 获得预处理对象,需要提供已经使用占位符处理后的SQL语句
		PreparedStatement psmt = conn.prepareStatement(sql)
	2.设置实际参数
		void setXxx(int index, Xxx xx) 将指定参数设置指定类型的值
			参数1: index 实际参数序列号,从1开始。
			参数2: xxx 实际参数值,xxx表示具体的类型。
		例如:
			setString(2, "1234")SQL语句中第2个位置的占位符?替换成实际参数 "1234"
	3.执行SQL语句
		int executeUpdate(): --执行insert update delete语句.
		ResultSet executeQuery(): --执行select语句.
		boolean execute(): --执行select返回true 执行其他的语句返回false.
3.2 基于预处理完成相关的操作
package com.itheima.day05;

import java.sql.*;
import java.util.Scanner;

public class JDBCDemo {

    private static Statement statement;
    private static Connection conn;

    // 静态代码块:这里不能抛出异常
    static{
        try{
            // 1- 注册驱动。通过反射创建
            Class.forName("com.mysql.jdbc.Driver");

            // 2- 获取数据库连接
            String url = "jdbc:mysql://192.168.88.166:3306/day04_jdbc?useUnicode=true&characterEncoding=utf8&useSSL=false";
            conn = DriverManager.getConnection(url, "root", "123456");

            // 3- 获取SQL执行对象
            statement = conn.createStatement();
        }catch(Exception e){
            e.printStackTrace();
            // throw new RuntimeException();
        }
    }

    public static void main(String[] args) {
        JDBCDemo jdbcDemo = new JDBCDemo();
        Scanner sc = new Scanner(System.in);

        in:while(true){
            System.out.println("请输入操作选项1新增,2删除,3修改,4查询,5停止操作:");
            int inputOption = sc.nextInt();

            switch (inputOption){
                case 1:
                    System.out.println("请输入新用户ID:");
                    int insertUserId = sc.nextInt();
                    jdbcDemo.insert(insertUserId);
                    break;

                case 2:
                    System.out.println("请输入要删除的用户ID:");
                    int deleteUserId = sc.nextInt();
                    jdbcDemo.delete(deleteUserId);
                    break;

                case 3:
                    System.out.println("请输入要更新的用户ID:");
                    int updateUserId = sc.nextInt();
                    jdbcDemo.update(updateUserId);
                    break;

                case 4:
                    System.out.println("请输入要查询的用户ID:");
                    int queryUserId = sc.nextInt();

                    System.out.println("请输入要查询的用户姓名:");
                    String queryUserName = sc.next();
//                    jdbcDemo.query(queryUserId,queryUserName);

                    // SQL注入
//                    String queryUserName = "' or 1=1 or '";

                    jdbcDemo.queryPreparedStatement(queryUserId,queryUserName);
                    break;

                case 5:
                    break in;

                default:
                    System.out.println("您输入的选项有误,"+inputOption);
                    break;
            }
        }
    }

    public void insert(int id) {
        try{
            // 执行插入语句
            String sql = "insert into stu (id,name,age,address) values("+id+",'王六',22,'深圳')";
            // 表示影响的数据条数
            int result = statement.executeUpdate(sql);
            System.out.println(result);
        }catch (Exception e){
            e.printStackTrace();
            // 实际在工作中需要将异常输出到日志文件
        }
    }

    public void delete(int id){
        try{
            // 执行删除语句
            String sql = "delete from stu where id="+id;
            // 表示影响的数据条数
            int result = statement.executeUpdate(sql);
            System.out.println(result);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public void update(int id){
        try{
            // 执行删除语句
            String sql = "update stu set name='周三',age=99 where id="+id;
            // 表示影响的数据条数
            int result = statement.executeUpdate(sql);
            System.out.println(result);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /*
        避免SQL注入,使用preparedStatement
     */
    public void queryPreparedStatement(int id, String name){
        ResultSet rs = null;
        try{
            String sql = "select * from stu where id=? and name=?";

            PreparedStatement preparedStatement = conn.prepareStatement(sql);

            // 设置参数。参数的序号从1开始
            preparedStatement.setInt(1,id);
            preparedStatement.setString(2,name);
            System.out.println(preparedStatement);

            rs = preparedStatement.executeQuery();

            // 5- 处理返回结果
            while (rs.next()){
                int age = rs.getInt("age");
                String address = rs.getString("address");
                System.out.println(age+","+address);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 释放资源
            try {
                if(rs != null){
                    rs.close();
                }
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public void query(int id, String name){
        ResultSet rs = null;
        try{
            String sql = "select * from stu where id="+id+" and name='"+name+"'";
            System.out.println(sql);
            rs = statement.executeQuery(sql);
            System.out.println(rs);

            // 5- 处理返回结果
            while (rs.next()){
                int age = rs.getInt("age");
                String address = rs.getString("address");
                System.out.println(age+","+address);
            }

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            // 释放资源
            try {
                if(rs != null){
                    rs.close();
                }
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

添加数据

package com.itheima.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class Demo02_JDBC_Insert {

    public static void main(String[] args) throws Exception {
        //1. 注册驱动
        Class.forName("com.mysql.jdbc.Driver");

        //2. 根据连接管理器, 创建连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://node1:3306/day05_jdbc?useUnicode=true&characterEncoding=utf8", "root", "123456");

        //3. 根据连接对象, 创建SQL语句的执行平台(预编译)
        String sql = "insert into `user` values(?,?,?)";
        PreparedStatement stat = conn.prepareStatement(sql);

        //4. 执行SQL语句
        // 4.1 为 ? 赋值
        stat.setInt(1,4);
        stat.setString(2,"zhaoliu");
        stat.setString(3,"147");

        // 4.2 执行SQL
        int i = stat.executeUpdate();

        //5 处理结果集
        System.out.println("影响了:"+ i);

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

4、连接池相关内容

4.1连接池原理

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

在这里插入图片描述

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

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

​ 常见的连接池:C3P0、DRUID。

4.2 C3P0连接池工具类实现

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

使用步骤:

  • 1- 将C3P0的jar包, 添加到当前项目的lib目录中, 并且设置到开发环境中
    在这里插入图片描述
    在这里插入图片描述

  • 2- 添加C3P0的配置文件

    • 注意: 配置文件必须放置在SRC的resources目录下, 否则无法自动加载到的
      在这里插入图片描述
  • 3- 修改配置文件

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
	<default-config>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql://192.168.88.166:3306/day04_jdbc?useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false</property>
		<property name="user">root</property>
		<property name="password">123456</property>
		
		<property name="initialPoolSize">5</property>
		<property name="minPoolSize">5</property>
		<property name="maxPoolSize">20</property>
	</default-config> 
  • 4- 编写代码, 测试连接池如何使用
package com.itheima.day05;
import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class 连接池使用 {
    public static void main(String[] args) throws Exception {

        //1.创建连接池对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource(); // 当创建这个连接池的时候, 自动到src目录下加载 C3P0的配置文件
        //2. 从连接池中获取连接
        Connection conn = dataSource.getConnection();
        //3. 获取SQL语句的执行平台
        String sql = "select  * from stu ";
        PreparedStatement stat = conn.prepareStatement(sql);
        //4. 执行SQL
        ResultSet rs = stat.executeQuery();
        //5. 处理结果集

        while(rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");

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

        //6. 释放步骤
        rs.close();
        stat.close();
        conn.close(); // 此操作并不会关闭连接, 而是归还给连接池
    }
}

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

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

package com.itheima.jdbc;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class C3P0Utils {

    private C3P0Utils() {
    }
    //1.创建连接池对象
    private static ComboPooledDataSource dataSource = new ComboPooledDataSource();

    // 获取连接
    public static Connection getConnection() throws Exception{

        return dataSource.getConnection();

    }

    //释放资源
    public static void close(ResultSet resultSet,
                             Statement statement,
                             Connection conn) throws SQLException {

        if(resultSet!=null){
            resultSet.close();
        }

        if (statement!=null) {
            statement.close();
        }

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

测试工具类

package com.itheima.jdbc;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

public class Test06_连接池工具类使用 {
    public static void main(String[] args) throws Exception {
        //1. 从连接池中获取连接
        Connection conn = C3P0Utils.getConnection();
        //2. 获取SQL语句的执行平台
        String sql = "select  * from user ";
        PreparedStatement stat = conn.prepareStatement(sql);
        //3. 执行SQL
        ResultSet rs = stat.executeQuery();
        //4. 处理结果集

        while(rs.next()){
            int id = rs.getInt("id");
            String name = rs.getString("name");

            System.out.println("id:"+id +";name:"+name);
        }
        //5. 释放步骤
       C3P0Utils.close(rs,stat,conn);

    }
}

三、多线程(了解)

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

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

注意:Java中只有多线程,没有多进程。

1、并发与并行

并行:指两个或多个事件在同一时刻发生(同时发生)。

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

在这里插入图片描述

2、线程与进程

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

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

总结:

进程是程序底层运行的表现。

进程是资源分配的最小单位。

线程不能独立于进程存在,也就是线程必须在进程中。

在这里插入图片描述

在这里插入图片描述

3、创建线程类

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

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

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

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

操作:

package com.itheima.thread;

public class MyThread extends Thread {

    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {

        for (int i = 1; i<=10 ;i++){
            System.out.println("子线程:"+ getName() + "  " +i);

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}


package com.itheima.thread;

public class Test01_myThread {

    // 多线程的特点:  随机性 和 延迟性
    public static void main(String[] args) throws Exception{ // main 主线程

        MyThread myThread = new MyThread("myThread-01"); // 指定线程的名字
        myThread.start(); // 启动子线程


        for (int i = 1; i<=10 ;i++){
            System.out.println("主线程:"+ Thread.currentThread().getName() + "  " +i);

            // 休眠一下
            Thread.sleep(10);
        }


    }
}

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():返回对当前正在执行的线程对象的引用。

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

演示接口方式:

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

代码:

package com.itheima.thread;

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

            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


package com.itheima.thread;

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

        //1. 创建MyRunnable对象
        MyRunnable myRunnable = new MyRunnable();

        //2. 创建线程类, 然后将 myRunnable对象 传入线程类中
        Thread thread = new Thread(myRunnable,"myRunnable-0");

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

        for (int i = 1; i<=10 ;i++){
            System.out.println("主线程:"+ Thread.currentThread().getName() + "  " +i);

            // 休眠一下
            Thread.sleep(10);
        }

    }
}

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

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

四、Maven基本介绍

Maven:读音 霉吻 麦吻。功能类似于Python中的pip

在这里插入图片描述

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

Maven的作用:

1) maven对项目的第三方构建(jar包)进行统一管理。向工程中加入jar包不要手工从其他地方拷贝, 通过maven定义jar包的坐标,自动从maven仓库中下载到工程中。

2) maven提供一套对项目生命周期管理的标准, 开发人员、和测试人员统一使用maven进行项目构建。项目生命周期管理: 编译、测试、打包、部署、运行。

3) maven对工程分模块构建,提高开发效率

1、Maven的仓库

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

在这里插入图片描述

在这里插入图片描述

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

2、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>

3、Maven安装

  • 1- 下载Maven安装包
    • http://maven.apache.org/download.cgi

在这里插入图片描述

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

在这里插入图片描述

  • 3- maven的目录介绍
    在这里插入图片描述

  • 4- 配置环境变量

MAVEN_HOME=E:\apache-maven-3.2.1

Path=%MAVEN_HOME%\bin;... ...

在这里插入图片描述
在这里插入图片描述

  • 5- 配置本地仓库

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

    在这里插入图片描述

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

在这里插入图片描述

  • 6- 测试maven安装成功

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

在这里插入图片描述

4、IDEA整合本地Maven

在这里插入图片描述
在这里插入图片描述

不建议参考上图, 上图为强制配置所谓路径, 建议使用下面的方案, 自动识别远端路径:
在这里插入图片描述

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

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

在这里插入图片描述

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

在这里插入图片描述

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

在这里插入图片描述

尝试通过一下方式处理:

在这里插入图片描述

  • 3- 创建Java代码
    在这里插入图片描述
package cn.itcast.dao;

public class ProductDao {

    public void add() {
        System.out.println("--------------------1 ProductDao.add()... ...");
    }

    public void del() {
        System.out.println("--------------------2 ProductDao.del()... ...");
    }

    public void edit() {
        System.out.println("--------------------3 ProductDao.edit().... ...");
    }

    public void query() {
        System.out.println("--------------------4 ProductDao.query()... ...");
    }
}

6、Maven的常用命令

在这里插入图片描述

  • clean命令
    在这里插入图片描述

  • compile命令

在这里插入图片描述

  • test命令
    • 测试命令: 执行 src/test/java 下junit的测试用例
      在这里插入图片描述

在这里插入图片描述

  • package命令
    • mvn package, 打包项目

在这里插入图片描述

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

在这里插入图片描述

  • install命令
    • mvn install, 打包后将其安装在本地仓库
      在这里插入图片描述

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

在这里插入图片描述

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

7、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>

8、依赖范围

在这里插入图片描述

  • 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
	当代码在编译的时候, 不需要这个jar包任何内容, 但是运行的时候, 需要使用jar包中相关嘞, 此时建议使用 runtime

默认为: compile

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


一般仅需要设置 provided, 当对当前项目进行打包的时候, 如果不需要将某些jar包打包到整个项目的jar包中, 此时设置此范围

9、Java版的Spark词频统计

  • 创建项目

参考前面的第5章节

  • pom.xml配置文件。将如下内容直接复制粘贴到pom.xml文件中
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>java_spark</artifactId>
    <version>1.0-SNAPSHOT</version>

    <sql>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </sql>

    <!-- 指定仓库位置,依次为aliyun、apache和cloudera仓库 -->
    <repositories>
        <repository>
            <id>aliyun</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </repository>

        <repository>
            <id>apache</id>
            <url>https://repository.apache.org/content/repositories/snapshots/</url>
        </repository>

        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>

    <dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.12</artifactId>
            <version>3.1.2</version>
        </dependency>
    </dependencies>

    <build>
        <sourceDirectory>src/main/java</sourceDirectory>
        <plugins>
            <!-- 编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <!--<encoding>${project.build.sourceEncoding}</encoding>-->
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.18.1</version>
                <configuration>
                    <useFile>false</useFile>
                    <disableXmlReport>true</disableXmlReport>
                    <includes>
                        <include>**/*Test.*</include>
                        <include>**/*Suite.*</include>
                    </includes>
                </configuration>
            </plugin>

            <!-- 打包插件(会包含所有依赖) -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <!--
                                        zip -d learn_spark.jar META-INF/*.RSA META-INF/*.DSA META-INF/*.SF -->
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <!-- 设置jar包的入口类(可选) -->
                                    <mainClass></mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>
  • 代码
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import scala.Tuple2;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class SparkWordCount {
    public static void main(String[] args) {
        // 1- 创建顶级对象
        SparkConf conf = new SparkConf().setAppName("sparkwordcount").setMaster("local[*]");
        JavaSparkContext sc = new JavaSparkContext(conf);

        // 2- 读取数据
        JavaRDD<String> initRDD = sc.textFile("D:\\code\\java_spark\\content.txt");

        // 3- 数据处理
        // 3.1- 文本内容切分得到单个的单词
//        initRDD.flatMap(new FlatMapFunction<String, String>() {
//            @Override
//            public Iterator<String> call(String line) throws Exception {
//                return Arrays.asList(line.split(" ")).iterator();
//            }
//        });

        JavaRDD<String> words = initRDD.flatMap(line -> Arrays.asList(line.split(" ")).iterator());

        // 3.2- 数据格式转换。hello -> (hello,1)
        JavaPairRDD<String, Integer> wordPairs = words.mapToPair(new PairFunction<String, String, Integer>() {
            @Override
            public Tuple2<String, Integer> call(String s) throws Exception {
                return Tuple2.apply(s, 1);
            }
        });

        // 进行词频统计
        JavaPairRDD<String, Integer> result = wordPairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });

        // Lambda表达式写法
        List<Tuple2<String, Integer>> lambdaResult = sc.textFile("D:\\code\\java_spark\\content.txt")
                .flatMap(line -> Arrays.asList(line.split(" ")).iterator())
                .mapToPair(word -> Tuple2.apply(word, 1))
                .reduceByKey((v1, v2) -> v1 + v2)
                .collect();

        // 4- 数据输出
        List<Tuple2<String, Integer>> resultList = result.collect();
        System.out.println(resultList);
        System.out.println(lambdaResult);

        // 5- 释放资源
        sc.stop();
    }
}

网站公告

今日签到

点亮在社区的每一天
去签到