java基础 day16线程池，反射机制，获取Class，访问属性Filed，访问方法Method（），配置dom4j

铅笔芯片

已于 2022-03-30 07:47:43 修改

阅读量137

点赞数

分类专栏： JAVA基础文章标签： eclipse java 面试

于 2022-03-29 08:23:08 首次发布

本文链接：https://blog.csdn.net/weixin_43734992/article/details/123787478

版权

JAVA基础专栏收录该内容

21 篇文章 0 订阅

订阅专栏

线程池

池化思想：线程池、字符串常量池、数据库连接池
目的：提高资源的利用率
原来模式：

手动创建线程对象
执行任务
执行完毕，释放线程任务

优点：提高线程利用率和程序的响应速度，便于统一管理线程对象，可以控制最大的并发数量。

package pro1;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test1 {
	public static void main(String[] args) {
		// 执行业务的业务类
		ExecutorService es = Executors.newSingleThreadExecutor();
		// 指定数量的线程池
		ExecutorService es1 = Executors.newFixedThreadPool(5);
		// 创建不定数量的缓存线程池
		ExecutorService es2 = Executors.newCachedThreadPool();

		es.execute(new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				for (int i = 0; i < 5; i++) {
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + "的值为： " + i);
				}
			}
		});
		Future<Long> result = es.submit(new Callable<Long>() {

			@Override
			public Long call() throws Exception {
				// TODO Auto-generated method stub
				int sum = 0;
				for (int i = 0; i < 100; i++) {
					sum += i;
				}
				return Long.valueOf(sum);
			}

		});
		try {
			System.out.println(result.get());

		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

反射机制

通过java语言中的反射机制，可以直接操作字节码文件。
反射机制的相关类在：java.lang. reflect.;
反射机制相关的重要的类有哪些?

java. lang.Class：代表整个字节码，代表一个类型。
java . lang. reflect . Method：代表字节码中的方法字节码，代表类中的方法。
java. lang. reflect . Constructor代表字节码中的构造方法字节码，代表类中的构造方法
java. lang. reflect. Field：代表字节码中的属性字节码，代表类中的成员变量：静态变量和实例变量。

package reflect;

//java.lang.Class
public class User {
	//Field
	private int no;
	//Concentrator
	public User(int no) {
		super();
		this.no = no;
	}
   //Method
	public int getNo() {
		return no;
	}

	public void setNo(int no) {
		this.no = no;
	}

}

获取Class的三种方式

package reflect;

import java.util.Date;

import javax.xml.crypto.Data;

/* 要操作一个类的字节码，需要首先获取到这个类的字节码,怎么获取java.lang.Class实例?
   三种方式：
   第一种:Class c = Class.forName("完整类名带包名");
   第二种:Class c =对象.getClass(); 
   第三种：Class c = 数据类型.class

*/
public class ReflectTest01 {
	public static void main(String[] args) {
		/*
		 方法1：Class.forName() 
		 1.静态方法
		 2、方法的参数是一个字符串。
		 3、字符串需要的是-个完整类名。
		 4、完整类名必须带有包名。java.lang包也不能省略。		  
		 */
		Class c1 = null;
		try {
		    c1 = Class.forName("java.lang.String");//c1代表string.class文件,或者说c1代表String类型。
			Class c2 = Class.forName("java.util.Date");//c2代表Date类型
			Class c3 = Class.forName("java.lang.Integer");//c3代表Integer类型
			Class c4 = Class.forName("java.lang.System");//c4代表System类型
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		//方法2：java中对象都有一个方法叫.getClass()
		String s = "abc";
		Class class1 = s.getClass();//class1代表String.class字节码文件，代表String类型
		System.out.println(c1 == class1);//保存的内存地址是一样的，都指向String.class文件。true
		
		//方法3：java语言中任何一种类型，包括基本数据类型，都有.class属性
		Class class2 = String.class;
		Class class3 = Date.class;
		System.out.println(class1 == class2);//true;		
	}
}

获取到class可以做什么？

package reflect;

/*
获取到class能干嘛？
通过class的newInstance()方法来实例化对象。
注意:newInstance()方法内部实际上调用了无参构造方法,必须保证无参构造存在才可以。
 */
public class ReflectTest02 {
	public static void main(String[] args) {
		// 这是不使用反射机制,创建对象
		User user = new User();
		System.out.println(user);

		// 下面这段代码是 以反射机制的方式创建对象。
		try {
			Class class1 = Class.forName("reflect.User");
			// newInstance会调用User的无参构造方法，完成对象构造,必须保证无参构造存在
			// 没有无参构造时，报错：InstantiationException
			Object object = class1.newInstance();
			System.out.println(object);

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}
}

反射机制的灵活性

classinfo.properties:

className = reflect.User

ReflectTest03:

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Properties;

/*
 * 反射对象的灵活性：
 * java对象写一遍，不改变java源代码基础上，可以做到不同对象的实例化
 * 符合OCP开闭原则，对扩展开放，对修改关闭
 */
public class ReflectTest03 {
//通过IO流读取reflect.User文件
	public static void main(String[] args) throws FileNotFoundException {
		FileReader fileReader = new FileReader(
				"C:\\Users\\Zhouliting\\eclipse-workspace\\javaProject0328\\src\\classinfo.properties");
		// 创建属性类对象Map。,key,value都是对象
		Properties properties = new Properties();
		// 加载
		try {
			properties.load(fileReader);
			fileReader.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// 通过key获取value;
		String classNameString = properties.getProperty("className");
		System.out.println(classNameString);
		// 通过反射机制实例化对象
		Class class1;
		try {
			class1 = Class.forName(classNameString);
			Object object = class1.newInstance();
			System.out.println(object);
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		/*
		 * reflect.User 
		 * 无参构造方法！ 
		 * reflect.User@279f2327
		 */

	}

}

只让静态代码块执行

如果只是希望一个类的静态代码块执行,其它代码一律不执行，可以使用:Class. forName(“完整类名”);这个方法的执行会导致类加载,类加载时,静态代码块执行。

package reflect;

/*
 * 研究一下：Class.forName()发生了什么
 */
public class ReflectTest04 {
	public static void main(String[] args) {
		try {
			Class.forName("reflect.Myclass");
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

class Myclass {
	// 静态代码块在类加载时执行，并且只执行一次
	static {
		// TODO Auto-generated method stub
		System.out.println("Myclass类的静态代码块执行了！");
	}
}

绝对路径：Thread.currentThread().getContextClassLoader().getResource(“classinfo.properties”).getPath();

package reflect;

/*
 * 研究一下文件路径问题
 */
public class AboutPath {
	/*
	 * 比较通用的路径，代码换位置依然通用,前提是：文件在类路径下（src下） src是类的根路径
	 */
	public static void main(String[] args) {
		/*
		 * Thread.currentThread()当前线程对象
		 * getContextClassloader()是线程对象的方法，可以获取到当前线程的类加载器对象。 getResource()
		 * 这是类加载器对象的方法,当前线程的类加载器默认从类的根路径下加载资源。
		 */
		// 绝对路径
		String path = Thread.currentThread().getContextClassLoader().getResource("classinfo.properties").getPath();

		System.out.println(path);
	}
}

资源绑定器：ResourceBundle

package reflect;
/*java.util包下提供了一个资源绑定器,便于获取属性配置文件中的内容。
使用以下这种方式的时候,属性配置文件xx. properties必须放到类路径下。
*/
import java.util.ResourceBundle;

public class resourceBundleTest {
	public static void main(String[] args) {
		// 资源绑定器,只能绑定xxx. properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
		// 并且在写路径的时候,路径后面的扩展名不能写。
		ResourceBundle bundle = ResourceBundle.getBundle("classinfo");
		String className = bundle.getString("className");
		System.out.println(className);
	}
}

获取属性，Filed！！！！！

Student类

package reflect;
//反射属性Field
public class Student {
	//4个Field，分别采用不同的访问控制权限修饰符
	public int no;
	private String name ;
	protected int age;
	boolean sex;
	public static final double PI = 3.1415926;
}

ReflectTest05类，反射所有的Filed

package reflect;

import java.io.File;
import java.lang.module.ModuleDescriptor.Exports.Modifier;
import java.lang.reflect.Field;

/*
 * 反射Student类中所有的Field
 */
public class ReflectTest05 {
	public static void main(String[] args) throws ClassNotFoundException {
		// 获取整个类
		Class studentClass = Class.forName("reflect.Student");
		// 获取类中所有的Field
		Field[] files = studentClass.getFields();
		System.out.println(files.length);

		Field f = files[0];
		// 取出Field的名字
		String fieldString = f.getName();// 只能得到public修饰的
		System.out.println(fieldString);

		// 获取类中所有的Field
		Field[] files1 = studentClass.getDeclaredFields();
		System.out.println(files1.length);
		for (Field field : files1) {

			// 获取属性的修饰符列表，修饰符可能有多个,返回修饰符的代号
			int i = field.getModifiers();
			System.out.println(i);

			// 可以将数字转换成字符串吗？此处存疑？？？？？？？
			String modeifierString = Modifier.toString(i);
			System.out.println(modeifierString);

			// 获取属性的类型
			Class fieldType = field.getType();
			String f1 = fieldType.getSimpleName();
			System.out.println(f1);

			// 获取属性的名字
			System.out.println(field.getName());

		}

	}
}

ReflectTest06类，怎么通过反射机制访问-个java对象的属性

package reflect;

import java.lang.reflect.Field;

/*
 * 必须掌握:
怎么通过反射机制访问-个java对象的属性?
给属性赋值set
获取属性的值get

 */
public class ReflectTest06 {
	public static void main(String[] args) throws ClassNotFoundException {
		Class studentClass = Class.forName("reflect.Student");
		// 使用反射机制，怎么修改和设置属性的值
		// 无参构造
		try {
			// 这样理解：给对象的某个属性赋值，分别获取对象，属性和值

			// 对象
			Object object = studentClass.newInstance();
			// 获取一个属性,根据属性的名称获取field
			Field noField = studentClass.getDeclaredField("no");

			// 给obj对象（Student对象）的no属性赋值
			noField.set(object, 2222);// 给obj对象的no属性赋值

			// 获取该属性的值
			System.out.println(noField.get(object));// 2222

			// 可以访问私有的属性吗？
			Field nameField = studentClass.getDeclaredField("name");
			// 打破封装（反射机制的缺点，可能会给不法分子留下机会）这样设置完之后，可以在外面访问private
			nameField.setAccessible(true);
			nameField.set(object, "张三");
			System.out.println(nameField.get(object));// 报错IllegalAccessException
			// 打破封装后输出：张三

		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

Method()使用反射机制调用一个方法!!!
反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了但是java代码不需要做任何改动。这就是反射机制的魅力。

示例：
UserService类：

package reflect;

public class UserService {
	private int no;
	private int age;
	//登录方法
	public boolean login(String name,String password) {
		if("admin".equals(name)&& "123".equals(password)) {
			return true;
		}
		return false;
	}
		
	public void logout(String name,String password) {
		System.out.println("系统已安全退出！");
		
	}
}

ReflectTest07类：实现用反射机制调用一个方法：

package reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.attribute.UserPrincipalLookupService;

/*
 * 重点：通过反射机制怎么调用一个对象的方法？
 */
public class ReflectTest07 {
	public static void main(String[] args) {
		// 不使用反射机制，调用方法
		UserService userService = new UserService();
		boolean success = userService.login("admin", "123");
		System.out.println(success ? "登陆成功" : "登陆失败");

		try {
			// 使用反射机制调用一个方法怎么做？
			// 类名
			Class userServiceClass = Class.forName("reflect.UserService");

			// 创建对象
			Object object = userServiceClass.newInstance();
			// 获取方法名,方法名和参数列表确定一个方法
			Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
			Method logoutMethod = userServiceClass.getDeclaredMethod("logout", String.class, String.class);
			// 调用方法:retValueObject返回值，object对象，"admin","123"实参
			Object retloginObject = loginMethod.invoke(object, "admin", "123");
			System.out.println(retloginObject);// true
			Object retlogoutObject = logoutMethod.invoke(object, "张三；", "123");
			System.out.println(retlogoutObject);

		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

作业：读取xml文件，根据文件的配置创建出相应类型的实例，通过反射机制设置对象的属性

Test类

package pro1;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/*
 * 作业：读取xml文件，根据文件的配置创建出相应类型的实例，通过反射机制设置对象的属性
 */
public class Test {
	public static void main(String[] args) throws NoSuchMethodException, SecurityException, NoSuchFieldException, DocumentException {
		Class<Person> person = Person.class;
		//可获取到类的私有构造器(包括带有其他修饰符的构造器)
		Constructor<Person> constructor = person.getDeclaredConstructor(String.class, String.class, String.class);
		InputStream istream = Test.class.getResourceAsStream("NewFile.xml");
		SAXReader reader = new SAXReader();

			try {
				//读取xml文件				
				Document doc = reader.read(istream);
				Element root = doc.getRootElement();
				List<Element> elements =  root.elements();
				for(Element element:elements) {
					Element name = element.element("name");
					Element sex = element.element("sex");
					Element age =  element.element("age");
					Person p = constructor.newInstance(name.getText(),sex.getText(),age.getText());
									
					Field f1 = person.getDeclaredField("name");
					Field f2 = person.getDeclaredField("sex");
					Field f3 = person.getDeclaredField("age");
					
					f1.setAccessible(true);
					f2.setAccessible(true);
					f3.setAccessible(true);	
					
					f1.set(p, "李四");
					f2.set(p, "女");
					f3.set(p, "20");
					System.out.println(p);					
				}
			} catch (NumberFormatException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InstantiationException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally {
				if(istream!= null) {
					try {
						istream.close();
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}		
	}
}

person类

package pro1;

public class Person {
	private String name;
	private String sex;
	private String age;
	public Person(String name, String sex, String age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	public String getNameString() {
		return name;
	}
	public void setNameString(String nameString) {
		this.name = nameString;
	}
	public String getSexString() {
		return sex;
	}
	public void setSexString(String sexString) {
		this.sex = sexString;
	}
	public String getAge() {
		return age;
	}
	public void setAge(String age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [nameString=" + name + ", sexString=" + sex + ", age=" + age + "]";
	}
}

NewFile.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<bean class="pro1.Person">
		<name>张三</name>
		<sex>男</sex>
		<age>20</age>

	</bean>
</beans>

配置dom4j

点击doc->在当前目录的的文件（project）下右键new->Folder->命名为lib
复制文件到lib
文件（project）右键->Build Path->Configure Build Path-> Java Build Path->Libraries->Classpath->Add JARs->选中该文件下的dom4j->Apply and Close