Java开发实践08-0131

一、今日内容

1、反射

（1）基本概念

Java反射机制是在运行状志中，获取任意一个类的结构，创建对象、得到方法、执行方法、属性。这种在运行状态动态获取信息以及动态调用对象方法的功能被称为java语言的反射机制。

（2）类加载器

    ① Java类加载器(java Classloader)是java运行时环境 (java Runtime Environment) 的一部分，负责动态加载java类到java虚拟机的内存空间中。

    ② java默认有三种类加载器：BootstrapClassLoader、ExtensionClassLoader、AppClassLoader。

      a. BootstrapClassLoader (引导启动类加载器）：敢在JVM内核中的加载器，该加载器是用C十+语言写的，主要负费加裁JAVA_ HOME/lib下的类库，引导启动类加载器无法被应用程序直接使用。

      b. ExtensionClassLoader（扩展类加加载器）： ExtensionClassLoader是用JAVA编写，目它的父类加载器是Bootstrap。是由sur.misc.Launcher$ExtClassLoader实现的，主要加载JAVA_ HOME/lib/ext目录中的类库。它的父类加载器是BootstrapClassloader。

      c. AppClassloader（应用类加载器）： AppClassLoader是应用程序类加载器，负费加裁应用程序classpath目录下的所有jar和class文件。它的父类加载器为ExtensionClassLoader。

    ③ 类通常是按需加载，即第一次使用该类时才加载。由于有了类加载器，Java运行时系统不需要知道文件与文件系统。学习类加载器时，掌握java的委派概念很重要。

    ④ 双亲委派模型：如果一个类加载器收到了—个类加载请求，它不会自己去尝试加载这个类，而是把这个请求转交给父类加载器去完成。每一个层次的类加载器都是如此。因此所有的类加载请求都应该传递到最顶层的启动类加载器中，只有到父类加载器反馈自己无法完成这个加载清求（在它的搜家范围没有找到这个类） 时，子类加载器才会尝试自己去加载。委派的好处就是避免有些类被重复加载。

（3）反射的基本用法

    ① 所有类型的Class对象

要想了解一个类，必须先要获取到该类的字节码文件对象；在java中，每一个字节码文件，被加载到内存后，都存在一个对应的Class类型的对象。

    ② 得到Class的几种方式

      a. 如果在编写代码时，指导类的名称，且类已经存在，可以通过

          包名.类名.class 得到一个类的类对象

      b. 如果拥有类的对象，可以通过

          Class 对象.getClass()得到一个类的类对象

      c. 如果在编写代码时，知道类的名称，可以通过

          Class.forName(包名＋类名);得到一个类的类对象

上述三种方式在调用时，如果类在内存中不存在，则会加载到内存如果类已经在内存中存在，不会重复加载,而是重复利用！

（—个class文件在内存中不会存在两个类对象）

    ③ 特殊的类对象

      a. 基本数据类型的类对象：基本数据类型.class；包装类.type

      b. 基本数据类型包装类对象：包装类.class

（4）获取Constructor

      ① 通过Class对象 获取一个类的构造方法

a. 通过指定的参数类型，获取指定的单个构造方法                getConstructor(参数类型的class对象）          例如：构造方法如下：Person (String name, int age)                     得到这个构造方法的代码如下：                      Conatructor c = p.getclass().getConstructor (String.class, int.class);
b. 获取构造方法数组	- getConstructors();
c. 获取所有权限的单个构造方法	- getDeclaredConstructor（参数类型的class对象数组）
d. 获取所有权限的构造方法数组	- getDeclaredConstructors ();

    ② Constructor创建对象

常用方法：

newinstanceObject...para)	- 调用这个构造方法，把对应的对象创建出来。
	- 参数：是一个Object类型可变参数，传递的参数顺序必须匹配构造方法中形式参数列表的顺序！
setAccessible (boolean flag)	- 如果flag为true则表示忽略访问权限检查！（可以访问任何权限的方法）

（5）获取Method

    ① 通过Class对象 获取一个类的方法

getMethod(String methodName, class...clss)	- 根据参数列表的类型和方法名，得到一个方法（public修饰的）
getMethodes()	- 得到一个类的所有方法（public修饰的）
getDeclaredMethod(String methodName, class clss)	- 根据参数列表的类型和方法名，得到一个方法（除继承以外所有的：包会私有，共有，保护，默认）
getDeclaredMethods();	- 得到一个类的所有方法（除继承以外所有的：包会私有，共有，保护，默认）

    ② Method执行方法

invoke(Object o, Object... para);	- 调用方法：     参数1.要调用方法的对象     参数2.要传递的参数列表
getName()	- 获取方法的方法名称
setAccessible (boolean flag)	- 如果flag为true则表示忽略访问权限检查！（可以访问任何权限的方法）

（6）获取Field

    ① 通过Class对象 获取一个类的属性

getDeclaredField (String = filedName)	- 根据属性的名称，获取一个属性对象（所有属性）
getDeclaredFields()	- 获取所有属性
getField(String filedName)	- 根据属性的名称，获取一个属性对象（public属性）
getFields	- 获取所有属性（public）

    ② Field属性的对象类型

常用方法：

get (Object o)	- 参数：要获取属性的对象，获取指定对象的此属性值
set (Object o, Object value)	- 参数1．要设置属性值的对象   参数2．要设置的值 设置指定对象的属性的值
getName ()	- 获取属性的名称
setAccessible (boolean flag)	- 如果flag为true则表示忽略访问权限检查！（可以访问任何权限的方法）

二、代码

1、Demo01

import java.io.*;

/**
 * @Author: ydh 2303
 * @description: 类加载器
 * @Date: 2024/1/31 11:05
 * @Version: 1.0
 */
public class Demo01 {
    public static void main(String[] args) {

//        ClassLoader classLoader = Demo01.class.getClassLoader();
//        System.out.println(classLoader.getParent().getParent());

        InputStream inputStream = Demo01.class.getClassLoader().getResourceAsStream("haha.txt");
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        try {
            String text = br.readLine();
            System.out.println(text);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在src下创建一个haha.txt

在Moudel下创建一个Directory-resouces-haha.txt

resouces需要：右击-Mark Directory as-Test Resources Root

先运行resouces当中的文件内容！

运行结果：

2、ClassTest

（1）getClassTest

获取Class对象

package com;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.time.Period;

/**
 * @Author: ydh 2303
 * @description: 获取Class对象
 * @Date: 2024/1/31 11:37
 * @Version: 1.0
 */
public class ClassTest {

    @Test
    public void getClassTest() throws ClassNotFoundException {

//        //获取Class对象，方式一:通过全类名.class的方式获取，已知一个类存在
//        Class c1 = Person.class;
//        System.out.println(c1);
//        System.out.println("-------------------------");
//
//        //获取Class对象，方式二:对象.getClass()得到类的Class对象
//        Person person = new Person();
//        Class c2 = person.getClass();
//        System.out.println(c2);
//        System.out.println(c1 == c2); //class  com.Person
//        System.out.println("-------------------------"); //true
//
//        //获取Class对象，方式三:Class.forName("全类名")，所谓的全类名就是包名+类名
//        Class c3 = Class.forName("com.Person");
//        System.out.println(c3);
//        System.out.println(c1 == c3 && c2 == c3);

        //推荐使用方式三
        Class c3 = Class.forName("com.Person");
        System.out.println(c3);

    }
}

（2）Person

创建一个空内容的Person类

package com;

/**
 * @Author: ydh 2303
 * @description:
 * @Date: 2024/1/31 11:39
 * @Version: 1.0
 */
public class Person {

}

运行结果：

3、Person

/**
 * @Author: ydh 2303
 * @description:
 * @Date: 2024/1/31 11:39
 * @Version: 1.0
 */
public class Person {
    private String  name;
    private int age;
    public String phoneNumber;

    public Person() {
    }

    private Person(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public Person(String name, int age, String phoneNumber) {
        this.name = name;
        this.age = age;
        this.phoneNumber = phoneNumber;
    }

    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 String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + ", phoneNumber='" + phoneNumber + '\'' + '}';
    }

    private void show(){
        System.out.println("你居然能调用我，很好！");
    }
}

4、ConstructorTest

需要用到3中的Person类

获取Constructor：通过Class对象获取一个类的构造方法；Constructor创建对象

import org.junit.Test;

import java.lang.reflect.Constructor;

/**
 * @Author: ydh 2303
 * @description: 获取Constructor
 *               通过Class对象获取一个类的构造方法
 *               Constructor创建对象
 * @Date: 2024/1/31 14:56
 * @Version: 1.0
 */
public class ConstructorTest {
    @Test
    public void getConstructorTest() throws Exception {
        //获取类的Class对象
        Class c = Class.forName("Person");
        //获取构造器public
        Constructor constructor = c.getConstructor();
        Object o = constructor.newInstance();
        System.out.println(o);

        //获取Person类中私有的构造器
        Constructor declaredConstructor = c.getDeclaredConstructor(String.class);
        declaredConstructor.setAccessible(true);
        Object o1 = declaredConstructor.newInstance("13593580928");
        System.out.println(o1);
    }
}

运行结果：

5、MethodTest

需要用到3中的Person类

获取Method：通过Class对象获取一个类的构造方法；Method执行方法

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

/**
 * @Author: ydh 2303
 * @description: 获取Method
 *               通过Class对象获取一个类的方法
 *               Method执行方法
 * @Date: 2024/1/31 15:23
 * @Version: 1.0
 */
public class MethodTest {
    @Test
    public void getMethodTest() throws Exception {
        //获取类的Class对象
        Class c = Class.forName("Person");
        //获取构造器public
        Constructor constructor = c.getConstructor();
        Object o = constructor.newInstance();

        Method setName = c.getMethod("setName", String.class);
        setName.invoke(o,"张三");
        System.out.println(o);
        System.out.println("---------------------------");

        Method declaredMethod = c.getDeclaredMethod("show");
        declaredMethod.setAccessible(true);
        declaredMethod.invoke(o);
        System.out.println(o);
    }
}

运行结果：

6、JDBCDmeo

JDBC 连接数据库

package com.java;

import java.sql.*;

/**
 * @Author: ydh 2303
 * @description: JDBC
 * @Date: 2024/1/31 16:15
 * @Version: 1.0
 */
public class JDBCDemo {
    public static void main(String[] args) {

        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        //六步走
        //1.在项目上新建一个文件夹lib导入MySOL驱动,并将jar加入到项目中
        try {
            //2.注册驱动，使用到了反射（方式三）
            Class.forName("com.mysql.cj.jdbc.Driver");

            //3.获取连接
            //ur1 = "jdbc:mysql://(ip):(端口)/(数据库名称)"
            String ur1 ="jdbc:mysql://39.107.73.184:3306/userdb";
            String username = "userdb";
            String password = "root";
            connection = DriverManager.getConnection(ur1, username, password);
            //System.out.println(connection);

            //4.获取预编译SOL，查询emp表中的数据
            String sql = "select * from emp";
            preparedStatement = connection.prepareStatement(sql);

            //5.查询，获取结果集（增删改，添加数据即可）并遍历;
            // 查询使用executeQuery()，增删改使用execute()或者executeUpdate()
            resultSet = preparedStatement.executeQuery();
            while (resultSet.next()){
                String ename = resultSet.getString("ename");
                String job = resultSet.getString("job");
                System.out.println(ename + " ====== " + job);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally{

            //6.释放资源Connection,PreparedStatement,ResultSet,释放时需从后往前
            //如果connection,preparedStatement,resultSet对象为null JVM GC
            if (resultSet != null){
                try {
                    resultSet.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (preparedStatement != null){
                try {
                    preparedStatement.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
            if (connection != null){
                try {
                    connection.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

    }


}

运行结果：

System.out.println(connection); //第3步连接数据库后首先测试一下是否能够正确运行。

select * from emp //第4步查询数据库里的内容，将其在数据库当中运行一下，查看是否可以顺利运行，最好在本数据库名称为userdb下查询运行。

7、com.util

（1）DBUtils

封装连接与关闭的工具等

package com.util;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

/**
 * @Author: ydh 2303
 * @description: 封装连接与关闭的工具等
 * @Date: 2024/1/31 17:27
 * @Version: 1.0
 */
public class DBUtils {
    private static String url = null;
    private static String username = null;
    private static String password = null;

    //静态代码块  只执行一次
    static{
        InputStream inputStream = DBUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        try {
            properties.load(inputStream);
            url = properties.getProperty("url");
            username= properties.getProperty("username");
            password = properties.getProperty("password");
            try {
                Class.forName("com.mysql.cj.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    public static void close(Connection resultSet, PreparedStatement preparedStatement, Connection connection){
        //6.释放资源Connection,PreparedStatement,ResultSet,释放时需从后往前
        //如果connection,preparedStatement,resultSet对象为null JVM GC
        if (resultSet != null){
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (preparedStatement != null){
            try {
                preparedStatement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

（2）DBUtilsTest

package com.util;

import org.junit.Test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import static org.junit.Assert.*;

/**
 * @Author: ydh 2303
 * @description:
 * @Date: 2024/1/31 17:39
 * @Version: 1.0
 */
public class DBUtilsTest {

    private static final String INSERT_SQL = "insert into emp(empno,ename,job) value(?,?,?)";
    private static final String UPDATE_SQL = "update emp set ename=?,job=? where empno=?";
    private static final String DELETE_SQL = "delete from emp where empno=?";

    @Test
    public void test01() throws SQLException {
        Connection connection = DBUtils.getConnection();
        System.out.println(connection);
    }

    //增加
    @Test
    public void insertTest(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = DBUtils.getConnection();
            preparedStatement = connection.prepareStatement(INSERT_SQL);
            preparedStatement.setString(1, "2024");
            preparedStatement.setString(2, "张三");
            preparedStatement.setString(3, "CEO");
            int i = preparedStatement.executeUpdate();
            if (i > 0){
                System.out.println("插入成功！");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally{
            DBUtils.close(connection, preparedStatement, null);
        }
    }

    //修改
    @Test
    public void updateTest(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = DBUtils.getConnection();
            preparedStatement = connection.prepareStatement(UPDATE_SQL);
            preparedStatement.setString(1, "钮钴禄");
            preparedStatement.setString(2, "董事长");
            preparedStatement.setString(3, "2024");
            int i = preparedStatement.executeUpdate();
            if (i > 0){
                System.out.println("修改成功！");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally{
            DBUtils.close(connection, preparedStatement, null);
        }
    }


    //删除
    @Test
    public void deleteTest(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = DBUtils.getConnection();
            preparedStatement = connection.prepareStatement(DELETE_SQL);
            preparedStatement.setString(1, "2024");
            boolean b = preparedStatement.execute();
            if (b != false){
                System.out.println("删除成功！");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally{
            DBUtils.close(connection, preparedStatement, null);
        }
    }
}

（3）Navicat

在数据库Navicat中加入MySQL语句：

insert into emp(empno,ename,job) value()

update emp set ename=?,job=? where empno=?

delete from emp where empno=?

运行结果：

插入成功！

修改成功！

删除成功！（我的电脑没有运行出来删除成功！）

三、总结

今天主要学习了反射的内容以及JDBC内容，连接数据库，还需巩固复习，加强练习！