黑马程序员_高新技术_知识总结二

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------

对注释、类加载器、代理、泛型、以及aop框架的理解。

1.         注释：注解的基本概念；

A.        @Deprecated这个注解是过时了的意思；它的生命周期是在运行期

@SuppressWarnings("deprecation")过时的注解；

B.        @Retention(RetentionPolicy.RUNTIME)添加了一个元注解; 这里面的参数代表着我们设置注解的生命周期是在运行时阶段；

C.         @Target({ElementType.METHOD,ElementType.TYPE})

这个注释是注解加在哪个上面；TYPE是只加在类上面；METHOD是指加在方法上；

D.        定义注解类的使用；

这个注释是注解加在哪个上面；TYPE是只加在类上面；METHOD是指加在方法上；

@Target({ElementType.METHOD,ElementType.TYPE})

public @interface ItcastAnnotation {

String color() default "blue";//注释类里面的属性

String value();

int[] arrayAttr() default {3,4,4};

//枚举类型的属性；我们找到固定的枚举类型EnumTest.TrafficLamp ，加上我们自己定义的属性lamp()；

EnumTest.TrafficLamp  lamp()  default EnumTest.TrafficLamp.RED;

//属性的返回类型是注释类型；@MetaAnnotation("lhm")是MetaAnnotation的

//实例对象；MetaAnnotation这个类中有一个value，所以我们传递参数；

MetaAnnotation annotationAttr() default @MetaAnnotation("lhm");

}

E.         类中使用注释类的方式，在类前面加，或者在类的方法上加；

@ItcastAnnotation(annotationAttr=@MetaAnnotation("flx"),color="red",value="abc",arrayAttr=1)

public class AnnotationTest {；

2.         类加载器的委托机制；就是要找父类；

             同一个文件存在不同阶段的时候，我们要找父类加载器，这个就叫做委托机制；

              爷爷类加载器：     bootStrap                加载的位置 jre/lib/rt.jar.

                类类加载器：         ExtClassLoader       加载的位置 jre/lib/ext/*.jar.

                   子类类加载器：     AppClassLoader     加载的位置 classpath 和指定的所有的jar者目录；

自己能不能写一个类，叫做java.lang.System.不能因为类加载器是委托机制，即使你写出来，它也不会加载，它会直接在根节点加载器bootStrap内的rt.jar内找出这个java.lang.System类；

                 但是我们自己可以写一个类加载器去加载；可以直接加载这个类java.lang.System.

3.         ClassLoaderTest.class.getClassLoader()得到类加载器，

         ClassLoaderTest.class.getClassLoader().getClass()得到类加载器这个类的字节码；

4.         用我们定义好的类加载器；

loadClass使用指定的二进制名称来加载类。

new MyClassLoader("itcastlib")是挂在系统的加载器上面，作为孩子；

itcastlib是我们自己定义的内部路径；通过这个内部路径通过findClass()方法来帮我们完成自定义加载我们自定义的加载器，加载这个被加密过的类；

作为孩子之后再加载loadClass("cn.itcast.day2.ClassLoaderAttachment")这个类；

//我们要把父类中的ClassLoaderAttachment.class删掉，这样父类的加载器就找不到这个类的文件了。  

Class clazz =

new MyClassLoader("itcastlib").loadClass("cn.itcast.day2.ClassLoaderAttachment");

clazz.newInstance()得到我们加密ClassLoaderAttachment类的父类，因为ClassLoaderAttachment是乱码类；

//编译器都不能通过了；这也就是我们之前要定义父类的原因了；

Date d1 =  (Date)clazz.newInstance();

System.out.println(d1);

5.         dao data access object--->crud  数据访问对象；crud是增删改查；

定义泛型类的注意事项

静态方法要自己定义自己的泛型方法，不能利用类里面的泛型；

public static <E> void update2(E obj){

}

6.         注意泛型是在编译器上检测的。他和字节码没关系；同一个集合泛型不一样，但是字节码是一样的；

         ArrayList<String> collection2 = new ArrayList<String>();

ArrayList<Integer> collection3 = new ArrayList<Integer>();

System.out.println(collection3.getClass() == collection2.getClass());     

7.         invoke(collection3, "abc")这个方法里面传递的两个参数的意思是

变量加参数的意思；collection3是集合的变量，abc是集合中的值；

如  collection3.add(abc);

8.         问号是通配符；可以接收任意类型的集合；但是通配符集合只能调用无参数的方法；

public static void printCollection(Collection<?> collection){

//collection.add(1);编译失败；

System.out.println(collection.size());

9.         //Vector<Date> 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()[0]);     

10.     代理的理解

代理就是代理其它的类做事情，在其他类的基础上，增加一些特有的方法；

A.        getProxyClass(ClassLoader loader, Class<?>... interfaces)

返回代理类的 java.lang.Class 对象，并向其提供类加载器和口；

Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);

 

B.        创建这个类的实例对象，

//得到我们之前打印出来的构造方法；获得构造方法的时候，我们传递的是参数的类型InvocationHandler；

Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);

                            //这里用了内部来创建对象；InvocationHandler接口的子类对象；

                            这里我们成功的获得了一个动态类对象，重点；我们通过构造方法来创建对象；

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

         public Object invoke(Object proxy, Method method, Object[] args)

                   throws Throwable {

                   return null;

                            }       

});

C.         获取代理的函数；

通过抽取方法，来建立获取代理的这个方法；getProxy  对任意类型都可以封装了，返回类型用Object

                            final Object target目标也是Object

                            private static Object getProxy(final Object target,final Advice advice) {

 

//newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。

                            Object proxy3 = Proxy.newProxyInstance(

                            给我什么样的目标，我就实现什么样的接口；

                            target.getClass().getClassLoader(),

                            target.getClass().getInterfaces(),//获取目标类的接口；

                            new InvocationHandler(){//创建一个内部类；

/**

 *每次调用方法的时候，都会调用invoke方法；

 * proxy调用这个代理对象；

 * 调用这个代理对象的哪个方法；

 * 调用这个方法的哪些参数；

 */           

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

                                               {                                            

                                      advice.beforeMethod(method);

                                     Object retVal = method.invoke(target, args);

                                     advice.afterMethod(method);

                                     return retVal;                                                

                   }

                   }

                                     );

                            return proxy3;

                   }

11.     AOP概念；

 

AOP框架的小应用程序的理解；

                   加载配置文件；

                   InputStream ips = AopFrameworkTest.class.getResourceAsStream("config.properties");

 

         new BeanFactory(ips)是传递一个配置文件进去；加载到properties当中，

         Properties props = new Properties();

//      我们装载配置文件，在Properties里面；

         public BeanFactory(InputStream ips){

                   try {

                            props.load(ips);

                   } catch (IOException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                   }

         }

getBean("xxx")通过传递名字，来看看是不是代理类；

//我们会得到这个类的实例；

         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 catch block

                            e.printStackTrace();

                   }

//判断一下类的类型；看看获取到的值，是不是代理类。

                   if(bean instanceof ProxyFactoryBean){

                   Object proxy = null;

//      转化成这个类的类型；

         ProxyFactoryBean proxyFactoryBean = (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.getProxy();

         } catch (Exception e) {

         // TODO Auto-generated catch block

         e.printStackTrace();

                   }

                            return proxy;

                   }

                   return bean;

         }

}             

//上面的代码是对这句话的扩展；

                   Object bean = new BeanFactory(ips).getBean("xxx");

                   输出这个类的名字；