『黑马程序员』第十一话<基础加强02>

最新推荐文章于 2017-01-10 01:15:00 发布

Jpor031

最新推荐文章于 2017-01-10 01:15:00 发布

阅读量546

点赞数

分类专栏：黑马Java自学日志

本文链接：https://blog.csdn.net/Jpor031/article/details/38037941

版权

黑马Java自学日志专栏收录该内容

13 篇文章 0 订阅

订阅专栏

30_对JavaBean的简单内省操作

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class IntroSpectorTest {

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

ReflectPoint pt1 = new ReflectPoint(3,5);

String propertyName = "x";

ObjectretVal = getProperty(pt1,propertyName);
System.out.println(retVal);

Objectvalue = 7;

setProperties(pt1,propertyName, value);
System.out.println(pt1.getX());
}

//设置value的值
private static void setProperties(Objectpt1, String propertyName,
Object value) throws IntrospectionException,
IllegalAccessException,InvocationTargetException {
PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodSetX = pd2.getWriteMethod();
methodSetX.invoke(pt1, value);
}

private static Object getProperty(Object pt1, String propertyName)
throws IntrospectionException, IllegalAccessException,
InvocationTargetException{
PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodGetX = pd.getReadMethod();
ObjectretVal = methodGetX.invoke(pt1);
return retVal;
}

小结：从上例可以看出Java Bean的优势：可以通过PropertyDescriptor（属性描述器？）来创建对象，然后用对象.getWriterMethod来获取写入的方法，然后再用invoke调用。这就是反射

31_使用BeanUtils工具包操作JavaBean

Bean工具包

1、演示用eclipse如何加入jar包，先只是引入beanutils包，等程序运行出错后再引入logging包。

2、在前面内省例子的基础上，用BeanUtils类先get原来设置好的属性，再将其set为一个新值。

get属性时返回的结果为字符串，set属性时可以接受任意类型的对象，通常使用字符串。

3、用PropertyUtils类先get原来设置好的属性，再将其set为一个新值。

get属性时返回的结果为该属性本来的类型，set属性时只接受该属性本来的类型。

4、演示去掉JavaBean（ReflectPoint）的public修饰符时，BeanUtils工具包访问javabean属性时出现的问题。

导入需要的jar包操作步骤：在javaenhance工程上单击鼠标右键-->New-->SourceFolder-->Floder Name:lib--.复制需要使用的jar包，直接粘贴到新建的lib目录下，然后将其增加到build path环境中：单击导入的jar包右键-->Build Path-->Add toBuild Path即可

在使用IntroSpectorTest.java的时候运用到了JavaUtils时，只导入commons-beanutils.jar包是不够的，而且会报错：org/apache/commons/logging/LogFactory，因此这里还需要按照导入beanutils jar包的方法导入logging包，并且添加到Build Path环境变量中

BeanUtils是以字符串的形式对JavaBean进行操作，而PropertyUtils则是对属性本身类型对JavaBean进行操作；如果需要类型转换，则使用BeanUtils，否则使用PropertyUtils

Map map = {name:"zxx",age:16};

BeanUtils.setProperty(map, "name", "lhm");*/

PropertyUtils.setProperty(pt1,"x", 9);

System.out.println(PropertyUtils.getProperty(pt1,"x").getClass().getName());

32_了解和入门注解的应用

了解注解及Java提供的几个基本注解

1、先通过@SuppressWarnings的应用让大家认识和了解一下注解：

通过System.runFinalizersOnExit(true);的编译警告引出@SuppressWarnings("deprecation")

2、@Deprecated

直接在刚才的类中增加一个方法，并加上@Deprecated标注，在另外一个类中调用这个方法。

3、@Override

public boolean equals(Reflect other)方法与HashSet结合讲解

常用几个注解

1.Deprecated value = RUNTIME

用@Deprecated特点注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时，编译器会发生

2.Override value = SOURCE

表示一个方法声明重写超类中的另个一方法声明。如果方法利用此注释类型进行注解但没有重写超类方法，则编译器会生成一条错误

3.SuppressWarnings value = SOURCE

指示应该注释元素（以及包含在该注释元素中的所有程序元素）中取消现实制定的编译器警告。注意，在给定元素中取消现实的警告集市所有包含元素中取消显示的警告的超集。例如，如果注释一个雷来取消显示某个警告，同事注释一个方法来取消显示另一个警告，那么僵在此方法中同时取消显示着两个警告。

public class AnnotationTest {
@SuppressWarnings("deprecation")
public static void main(String[] args) {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();
}
//1.标记某个方法过时；
//2.子类覆盖父类
//3.压缩警告
@Deprecated //提示编译器说明下面这个方法过时，让调用这个方法的程序能够识别
public static void sayHello(){
System.out.println("hi,黑马程序员");
}
}

33_注解的定义与反射调用

注解的应用

1、注解类

@interface A{}

2、应用了“注解类”的类

Class B{}

3、对“应用了注解类的类”进行反射操作的类

class C{

B.class.isAnnotionPresent(A.class);

A a = B.class.getAnnotion(A.class);

}

注解就相当于一个你的源程序中药调用的一个类，要在源程序中应用某个注解，得先准备好了这个注解类。就像你要调用某个类，得先有开发好了这个类。

自定义注解

根据反射测试的问题，引出@Retention元注解的讲解，其三种取值：

java源文件：RetetionPolicy.SOURCE、

class文件: RetetionPolicy.CLASS、

内存中的字节码: RetetionPolicy.RUNTIME;

其中，注解的默认阶段处在class文件阶段

注解里面的枚举：Java.lang.annotation Enum RetentionPolicy，其中该枚举有三个取值：CLASS：编译器将把注释记录在类文件中，但在运行时VM不需要保留注释。

RUNTIME：编译器将把注释记录在类文件中，在运行时VM将保留注释，因此可以反射性地读取。

SOURCE：编译器要丢弃的注释。

@ItheimaAnnotation
public class AnnotationTest {
@SuppressWarnings("deprecation")
@ItheimaAnnotation
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();

if(AnnotationTest.class.isAnnotationPresent(ItheimaAnnotation.class)){
ItheimaAnnotation annotation = (ItheimaAnnotation)AnnotationTest.class.getAnnotation(ItheimaAnnotation.class);
System.out.println(annotation);
}
}
//1.标记某个方法过时；
//2.子类覆盖父类
//3.压缩警告
@Deprecated //提示编译器说明下面这个方法过时，让调用这个方法的程序能够识别
public static void sayHello(){
//System.out.println("hi,黑马程序员");
}
}

34_为注解添加各种属性

1、什么是注解的属性

一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是传智播客的学生，否则，就不是。如果还想区分出是传智播客哪个班的学生，这时候可以为胸牌在增加一个属性来进行区分。加了属性的标记效果为：@MyAnnotation(color="red")

2、定义基本类型的属性和应用属性：

在注解类中增加String color();

@MyAnnotation(color="red")

3、用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法

MyAnnotation a =(MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);

System.out.println(a.color());

可以认为上面这个@MyAnnotation是MyAnnotaion类的一个实例对象

4、为属性指定缺省值：

String color()default "yellow";

5、value属性：

String value()default "zxx";

如果注解中有一个名称为value的属性，且你只想设置value属性（即其他属性都采用默认值或者你只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lhm")。

@ItheimaAnnotation(annotationAttr=@MetaAnnotation("flx"), color="red",value="abc", arrayAttr={1,2,3} )
public class AnnotationTest {
@SuppressWarnings("deprecation")
@ItheimaAnnotation("xyz")
public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
System.runFinalizersOnExit(true);
sayHello();

if(AnnotationTest.class.isAnnotationPresent(ItheimaAnnotation.class)){
ItheimaAnnotation annotation = (ItheimaAnnotation)AnnotationTest.class.getAnnotation(ItheimaAnnotation.class);

System.out.println(annotation.lamp().nextLamp().toString());
System.out.println(annotation.annotationAttr().value());
}
}
}

35_入门泛型的基本应用

import java.lang.reflect.Constructor;
import java.util.ArrayList;

public class GenericTest {

public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
/*ArrayList collection = new ArrayList();
collection.add(1);
collection.add(1L);
collection.add("abc");
int i =(Integer)collection.get(1);*/

ArrayList<String>al = new ArrayList<String>();
al.add("abc");
al.add("bbb");
al.add("acd");
String element =al.get(2);
System.out.println(element);

Constructor<String>constructor1 = String.class.getConstructor(StringBuffer.class);//这里的StringBuffer是选择哪个构造方法
//将Constructor添加String类型的泛型后，后面的返回值前就不再需要将其强制转换成String类型了
String str2 =constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
System.out.println(str2.charAt(2));
}

}

36_泛型的内部原理及更深应用

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

1、ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

1.整个称为ArrayList<E>泛型类型

2.ArrayList<E>中的E称为类型变量或类型参数

3.整个ArrayList<Integer>称为参数化的类型

4.ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

5.ArrayList<Integer>中的<>念着typeof

6.ArrayList称为原始类型

2、参数化类型与原始类型的兼容性：

1.参数化类型可以引用一个原始类型的对象，编译报告警告，例如，
Collection<String> c = new Vector();//可不可以，不就是编译器一句话的事吗？

2.原始类型可以引用一个参数化类型的对象，编译报告警告，例如，
Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去

3、参数化类型不考虑类型参数的继承关系：

Vector<String> v = new Vector<Object>(); //错误!

//不写<Object>没错，写了就是明知故犯

Vector<Object> v = new Vector<String>(); // 错误!

37_泛型的通配符扩展应用

1、使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

2、限定通配符的上边界：

正确：Vector<? extends Number> x = new Vector<Integer>();

错误：Vector<? extends Number> x = new Vector<String>();

3、限定通配符的下边界：

正确：Vector<? super Integer> x = new Vector<Number>();

错误：Vector<? super Integer> x = new Vector<Byte>();

38_泛型集合的综合应用案例

HashMap<String,Integer> maps = new HashMap<String,Integer>();
maps.put("zxx", 28);
maps.put("lhm", 35);
maps.put("flx", 33);

Set<Map.Entry<String,Integer>>entrySet = maps.entrySet();
for(Map.Entry<String, Integer> entry :entrySet){
System.out.println(entry.getKey() +":" + entry.getValue());
}

39_自定义泛型方法及其应用

1、自定义泛型模板中，其函数结构相似，但类型不同，这里可以使用一个通用的方法，它可以适用于各种类型，例如：

template<classT>

Tadd(T x,T y){

return(T)(x+y);

}

其中，代码里面的T代表一种任意数据类型

2、Java中的泛型类型（或者泛型）类似于C++中的模板。但是这种相似性仅限于表面，Java语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非凡行的字节码，这种实现技术成为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后再生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型呗认为是无法接受的，这会为Java厂商升级其JVM造成难以逾越的障碍。所以，Java的泛型采用了可以完全在编译器中实现的擦除方法。

3、泛型中是如何处理异常的

publicstatic <T extends Exception> sayHello() throws T{

try{}

catch(Exception e){

throw (T)e;

}

其中：T必定是Exception的子类，然后在处理catch的时候，还是用Exception e而不能用T代替，最后将抛出的e降至转换成(T)这种类型即可；

40_自定义泛型方法的练习与类型推断总结

泛型方法的练习题

1、编写一个泛型方法，自动将Object类型的对象转换成其他类型。

classGenericTest{

public static voidmain(String[] args){

Object obj = “abc”;

String a =autoConvert(obj);

}

public static <T> TautoConvert(Object obj){

return (T)obj;

}

2、根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

1.当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

swap(new String[3],3,4)  static <E> voidswap(E[] a, int i, int j)

2.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：

add(3,5)  static<T> T add(T a, T b)

3.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

fill(new Integer[3],3.5f)  static <T> void fill(T[] a, T v)

4.当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：

int x =(3,3.5f)  static <T> T add(T a, T b)

5.参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：

copy(newInteger[5],new String[5])  static <T> void copy(T[] a,T[] b);

copy(newVector<String>(), new Integer[5])  static <T> void copy(Collection<T> a , T[] b);

41_自定义泛型类的应用

1、如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：

publicclass GenericDao<T> {

privateT field1;

publicvoid save(T obj){}

publicT getById(int id){}

}

2、类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：

GenericDao<String> dao = null;

new genericDao<String>();

注意：

1.在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

2.当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。

import java.util.Set;

//dao--> Data Access Object:数据访问对象-->crud:create增、read检索、update改、delete删
public class GenericDao<T> {
//为了让程序里的T即返回值类型是统一的，如果只在方法上定义其返回值类型，最后得到的数据可能不是统一类型，
//因此这里可以将T返回值定义在类上，因此就能统一返回值类型，保证了数据的安全性
public void add(T x){ }
public T findById(int id){
return null;
}
public void delete(T obj){
}
public void delete(int id){
}
public void update(T obj){
}
public TfindByUserName(String name){
return null;
}
public Set<T> findByConditions(String where){
return null;
}
}

42_通过反射获得泛型的实际类型参数

class GenericTest{
public static void main(String[] args){
//以泛型的方式得到实际类型的参数
//Vector<Data> v1 = new Vector<Date>();
Method applyMethod =GenericTest.class.getMethod("applyVector", Vector.class);
Type[] types =applyMethod.getGenericParameterTypes();//获取参数值类型
ParameterizedType pType= (ParameterizedType)types[0];
System.out.println(pType.getRawType());
System.out.println(pType.getActualTypeArguments());
}

public static void applyVector(Vector<Date> v1){

}

43_类加载器及其委托机制的深入分析

1、Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader

2、类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是不是java类，这正是BootStrap。

3、Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。

public class ClassLoaderTest {

public static void main(String[] args) {
// TODO Auto-generated methodstub
Object obj = ClassLoaderTest.class.getClassLoader().getClass().getName();
System.out.println(obj);
Object obj1 = System.class.getClassLoader();
System.out.println(obj1);
//Java类加载器中有一个特殊的类加载器：BootStrap

ClassLoader loader =ClassLoaderTest.class.getClassLoader();
while(loader !=null){
System.out.println(loader.getClass().getName());//获取其类加载器的名称
loader =loader.getParent();//获取其类加载器的父类名称
}
System.out.println(loader);

}

}

4、类加载器的委托机制

1.当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？

a.首先当前线程的类加载器去加载线程中的第一个类。

b.如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。

c.还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

2.每个类加载器加载类时，又先委托给其上级类加载器。

a.当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个呢？

b.对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。

44_自定义类加载器的编写原理分析

1、自定义的类加载器的必须继承ClassLoader

loadClass方法与findClass方法

defineClass方法

2、编程步骤：

1.编写一个对文件内容进行简单加密的程序。

2.编写了一个自己的类装载器，可实现对加密过的类进行装载和解密。

3.编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName。

3、实验步骤：

1.对不带包名的class文件进行加密，加密结果存放到另外一个目录，例如： javaMyClassLoader MyTest.class F:\itcast

2.运行加载类的程序，结果能够被正常加载，但打印出来的类装载器名称为AppClassLoader：java MyClassLoader MyTest F:\itcast

3.用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。

4.删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。

4、findClass

protected Class<?> findClass(Stringname) throws ClassNotFoundException

使用指定的二进制名称查找类。此方法应该被类加载器的实现重写，该实现按照委托模型来加载雷。在通过父类加载器检查所请求的类后，此方法将被loadClass方法调用，默认实现抛出一个ClassNotFoundException；

45_编写对class文件进行加密的工具类

import java.util.Date;
public class ClassLoaderAttachmentextends Date {
public String toString(){
return "hello,itheima";
}
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class MyClassLoader {
//编写对class文件进行加密的工具类
public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
String srcPath =args[0];
String destDir = args[1];
FileInputStream fis = new FileInputStream(srcPath);
String destFileName =srcPath.substring(srcPath.lastIndexOf('\\')+1);
String destPath = destDir +"\\"+ destFileName;
FileOutputStream fos = new FileOutputStream(destPath);
cypher(fis,fos);
fis.close();
fos.close();

}
private static void cypher(InputStream ips,OutputStream ops)throws Exception{
int b = -1;
while((b=ips.read())!=-1){
ops.write(b ^ 0xff);
}
}

}

46_编写和测试自己编写的解密类加载器

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class MyClassLoader1 extends ClassLoader{

public static void main(String[] args)throws Exception {
// TODO Auto-generated methodstub
String srcPath = args[0];
String destDir = args[1];
FileInputStream fis = new FileInputStream(srcPath);
//目标原名称
String destFileName =srcPath.substring(srcPath.lastIndexOf('\\')+1);
//目标原路径
String destPath =destDir + "\\" + destFileName;
FileOutputStream fos = new FileOutputStream(destPath);

cypher(fis,fos);
fis.close();
fos.close();

}
public static void cypher(InputStream ips, OutputStream ops)throws Exception{
int b = -1;
while((b=ips.read())!=-1){
ops.write(b ^ 0xff);
}
}
//产生一个classDir成员变量
private String classDir;

@Override
protected Class<?> findClass(String name)throws ClassNotFoundException {
// TODO Auto-generated methodstub
String classFileName = classDir + "\\" + name.substring(name.lastIndexOf('.')+1) +".class";
try{
//由于这里是子类抛出异常,只能使用try,catch处理,因为其子类要抛的异常比父类范围大
FileInputStream fis= newFileInputStream(classFileName);
//定义一个字节输入流
ByteArrayOutputStreambos = new ByteArrayOutputStream();
cypher(fis,bos);
fis.close();
byte[] bytes = bos.toByteArray();
return defineClass(bytes,0,bytes.length);

}catch(Exception e){
e.printStackTrace();
}
return super.findClass(name);
}

//创建一个不带参数的MyClassLoader
public MyClassLoader1(){

//创建一个带参数的MyClassLoader
public MyClassLoader1(String classD
this.classDir

public class ClassLoaderTest {

public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
Object obj = ClassLoaderTest.class.getClassLoader().getClass().getName();
System.out.println(obj);
Object obj1 = System.class.getClassLoader();
System.out.println(obj1);
//Java类加载器中有一个特殊的类加载器：BootStrap

ClassLoader loader =ClassLoaderTest.class.getClassLoader();
while(loader !=null){
System.out.println(loader.getClass().getName());//获取其类加载器的名称
loader =loader.getParent();//获取其类加载器的父类名称
}
System.out.println(loader);

//System.out.println(new ClassLoaderAttachment().toString());

Class clazz = new MyClassLoader1("itheimalib").loadClass("com.itheima.day2.ClassLoaderAttachment");
//由于这里是自定义的ClassLoaderAttachment类,因此编译器是无法识别的,所以得将其强制转换
//ClassLoaderAttachment d1 = (ClassLoaderAttachment)clazz.newInstance();
//由于之前定义的是Date类,因此这里可以直接将其转成Date的类
Date d1 =(Date)clazz.newInstance();
System.out.println(d1);

}

}

import java.util.Date;

public class ClassLoaderAttachmentextends Date {
public StringtoString(){
return"hello,itheima";
}
}

47_类加载器的一个高级问题的实验分析

1.编写一个能打印出自己的类加载器名称和当前类加载器的父子结构关系链的MyServlet，正常发布后，看到打印结果为WebAppClassloader。

2.把MyServlet.class文件打jar包，放到ext目录中，重启tomcat，发现找不到HttpServlet的错误。

3.把servlet.jar也放到ext目录中，问题解决了，打印的结果是ExtclassLoader 。

48_分析代理类的作用与原理及AOP概念

代理的概念与作用

程序中的代理

1、要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？

2、编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。（参看下页的原理图）

3、如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。

class X{
void sayHello(){
System.out.println("hello,itheima");
}
}

XProxy{
void sayHello(){
starttime;
X.sayHello();
endtime;
}
}

AOP：交叉业务的编程问题即为面向方面的编程（Aspect orientedprogram ,简称AOP），AOP的目标就是要使交叉业务模块化。可以采用将切面代码移动到原始方法的周围，这与直接在方法中编写切面代码的运行效果是一样的，使用代理技术正好可以解决这种问题，代理是实现AOP功能的核心和关键技术

动态代理技术

1、要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！

2、JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。

3、JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

4、CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。

5、代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：

1.在调用目标方法之前

2.在调用目标方法之后

3.在调用目标方法前后

4.在处理目标方法异常的catch块中

49_创建动态类及查看其方法列表信息

1、分析JVM动态生成的类

1、创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。

2、编码列出动态类中的所有构造方法和参数签名

3、编码列出动态类中的所有方法和参数签名

4、创建动态类的实例对象

1.用反射获得构造方法

2.编写一个最简单的InvocationHandler类

3.调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去

4.打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。

5.将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。

5、总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?

三个方面：

1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；

2.产生的类字节码必须有个一个关联的类加载器对象；

3.生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。

6、用Proxy.newInstance方法直接一步就创建出代理对象。

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;

public class ProxyTest {

publicstatic void main(String[] args) {
//TODO Auto-generated method stub
ClassclazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(),Collection.class);;
System.out.println(clazzProxy1.getName());

//获取所有的构造方法,这里定义一个构造方法数组
System.out.println("----------beginconstructor----------");
/*
$Proxy0()
$Proxy0(InvocationHandler,int)
*/

Constructor[]constructors = clazzProxy1.getConstructors();
for(Constructorconstructor : constructors){
Stringname = constructor.getName();
//为了提高效率,这里使用StringBuilder,而StringBuilder不考虑安全问题,因此效率比StringBuffer更高
StringBuildersb = new StringBuilder(name);
sb.append('(');
Class[]clazzParams = constructor.getParameterTypes();
for(ClassclazzParam : clazzParams){
sb.append(clazzParam.getName()).append(',');
}
if(clazzParams!= null && clazzParams.length != 0)
sb.deleteCharAt(sb.length()-1);//删除最后一个元素
sb.append(')');
System.out.println(sb.toString());
}

//通过创建的动态类获取其所有方法
Method[]methods = clazzProxy1.getMethods();
for(Methodmethod : methods){
Stringname = method.getName();
//为了提高效率,这里使用StringBuilder,而StringBuilder不考虑安全问题,因此效率比StringBuffer更高
StringBuildersb = new StringBuilder(name);
sb.append('(');
Class[]clazzParams = method.getParameterTypes();
for(ClassclazzParam : clazzParams){
sb.append(clazzParam.getName()).append(',');
}
if(clazzParams!= null && clazzParams.length != 0)
sb.deleteCharAt(sb.length()-1);//删除最后一个元素
sb.append(')');
System.out.println(sb.toString());
}
}
}

50_创建动态类的实例对象及调用其方法

分析JVM动态生成的类

1、创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。

2、编码列出动态类中的所有构造方法和参数签名

3、编码列出动态类中的所有方法和参数签名

4、创建动态类的实例对象

1.用反射获得构造方法

2.编写一个最简单的InvocationHandler类

3.调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去

4.打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。

5.将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。

总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?

三个方面：

1.生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；

2.产生的类字节码必须有个一个关联的类加载器对象；

5、用Proxy.newInstance方法直接一步就创建出代理对象。

52_完成InvocationHandler对象的内部功能

Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated methodstub
return null;
}

});

Collection proxy3 =(Collection)Proxy.newProxyInstance(
Collection.class.getClassLoader(),//类加载器
new Class[]{Collection.class},//接口
new InvocationHandler(){
ArrayList target = new ArrayList();

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated methodstub

long startTime = System.currentTimeMillis();
Object retVal= method.invoke(target, args);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
return retVal;
}

});//InvocationHandler
proxy3.add("zxx");
proxy3.add("lhm");
proxy3.add("bxd");
System.out.println(proxy3.size());
}

53_总结分析动态代理类的设计原理与结构

1、分析动态代理的工作原理图

2、怎样将目标类传进去？

1.直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。

2.为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。

3.让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。

3、将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。

4、将系统功能代码模块化，即将切面代码也改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？

1.把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接收者只要调用这个对象的方法，即等于执行了外界提供的代码！

2.为bind方法增加一个Advice参数。

54_编写可生成代理和插入通告的通用方法

private static Object getProxy(final Object target,final Advice advice) {
Object proxy3 = Proxy.newProxyInstance(
//Collection.class.getClassLoader(),//类加载器
target.getClass().getClassLoader(),
/*new Class[]{Collection.class}, //接口*/
target.getClass().getInterfaces(),
new InvocationHandler(){
//把目标对象作为参数传递出去
//ArrayList target = new ArrayList();

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {

long startTime = System.currentTimeMillis();
advice.beforeMethod(method);
ObjectretVal = method.invoke(target, args);
advice.afterMethod(method);
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
return retVal;
}

});
return proxy3;
}

import java.lang.reflect.Method;

public interface Advice {
void beforeMethod(Method method);
void afterMethod(Methodmethod);
}

import java.lang.reflect.Method;

public class MyAdvice implements Advice {
long startTime = 0;
@Override
public void beforeMethod(Methodmethod) {
// TODO Auto-generated methodstub
System.out.println("到传智播客学习啦");
startTime = System.currentTimeMillis();
}

@Override
public void afterMethod(Method method){
// TODO Auto-generated methodstub
System.out.println("从传智播客毕业上班啦！");
long endTime = System.currentTimeMillis();
System.out.println(method.getName() +"running time is "+ (endTime - startTime)+"毫秒");
}

}

55_实现类似spring的可配置的AOP框架

实现AOP功能的封装与配置

1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。

2、BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：

#xxx=java.util.ArrayList

xxx=cn.itcast.ProxyFactoryBean

xxx.target=java.util.ArrayList

xxx.advice=cn.itcast.MyAdvice

3、ProxyFacotryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？

1.目标

2.通知

4、编写客户端应用：

1.编写实现Advice接口的类和在配置文件中进行配置

2.调用BeanFactory获取对象

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

import com.itheima.day3.Advice;

public class BeanFactory {
//定义一个配置文件
Properties props = new Properties();
public BeanFactory(InputStream ips) {
try {
props.load(ips);//加载输入的配置文件
} catch (IOException e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
}
//对于JavaBean来讲，一定要有一个不带参数的构造方法

public Object getBean(String name){
String className = props.getProperty(name);
Object bean = null;
try {
Class clazz =Class.forName(className);
bean =clazz.newInstance();
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
if(bean instanceof ProxyFactoryBean){
Object proxy = null;
ProxyFactoryBeanproxyFactoryBean = (ProxyFactoryBean)bean;
try {
Advice advice =(Advice)Class.forName(props.getProperty(name +".advice")).newInstance();
Object target =Class.forName(props.getProperty(name +".target")).newInstance();
proxyFactoryBean.setAdvice(advice);
proxyFactoryBean.setTarget(target);
proxy =((ProxyFactoryBean)bean).getProxy();
} catch (Exception e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
return proxy;
}
return bean;
}
}

#xxx=java.util.ArrayList
xxx=com.itheima.day3.aopframework.ProxyFactoryBean
xxx.advice=com.itheima.day3.MyAdvice
xxx.target=java.util.ArrayList

import java.io.InputStream;

public class AopFrameworkTest {

public static void main(String[] args)throws Exception{
// TODO Auto-generated methodstub
InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");
Object bean = new BeanFactory(ips).getBean("xxx");
System.out.println(bean.getClass().getName());
}

}