——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——

1.反射和内省

   反射:能动态修改Java代码,用于运行时检测修改某个对象的结构及其行为

   内省:内省是反射的一个子集,用于运行时检测某个对象的类型及其包含的属性

   JavaBean:是一种特殊的Java类,主要用于传递数据信息

   使用案例:

package cn.itcast.day1;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;

public class IntroSpectorTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		ReflectPoint pt1 = new ReflectPoint(3,5);
		
		String propertyName = "x";
		//"x"-->"X"-->"getX"-->MethodGetX-->
		//读取对象的字段
		Object retVal = getProperty(pt1, propertyName);
		System.out.println(retVal);
		
		Object value = 7;
		//修改对象的字段
		setProperties(pt1, propertyName, value);

		System.out.println("beantils:"+BeanUtils.getProperty(pt1, "x").getClass().getName());
		BeanUtils.setProperty(pt1, "x", "9");
		System.out.println(pt1.getX());
		
		/*//java7的新特性  ??????
		Map map = {name:"zxx",age:18};
		BeanUtils.setProperty(map, "na me", "lhm");
		 */
		BeanUtils.setProperty(pt1, "birthday.time", "111");
		System.out.println(BeanUtils.getProperty(pt1, "birthday.time"));
		
		PropertyUtils.setProperty(pt1, "x", 9);
		System.out.println("x="+pt1.getX());
		System.out.println(PropertyUtils.getProperty(pt1, "x").getClass().getName());
		
	}
    //直接利用属性描述器获取该字段的setter方法
	private static void setProperties(Object pt1, String propertyName,
			Object value) throws IntrospectionException,
			IllegalAccessException, InvocationTargetException {
		PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,pt1.getClass());
		Method methodSetX = pd2.getWriteMethod();
		methodSetX.invoke(pt1,value);
	}
    //通过内省机制获取该类的Javabean,在通过Javabean获取该类的所有成员信息:属性描述器 
	private static Object getProperty(Object pt1, String propertyName)
			throws IntrospectionException, IllegalAccessException,
			InvocationTargetException {
		/*PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());
		Method methodGetX = pd.getReadMethod();
		Object retVal = methodGetX.invoke(pt1);*/
		//获取pt1对象的beaninfo,它是用来传递数据的信息的
		BeanInfo beanInfo =  Introspector.getBeanInfo(pt1.getClass());
		//获取beaninfo中的所有属性描述器
		PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
		Object retVal = null;
		//遍历出想要的属性:propertyName
		for(PropertyDescriptor pd : pds){
			if(pd.getName().equals(propertyName))
			{
				//获取该属性的读取方法(getter)
				Method methodGetX = pd.getReadMethod();
				retVal = methodGetX.invoke(pt1);
				break;
			}
		}
		return retVal;
	}

}

2.类加载器

   类加载器:将类的字节码文件加载到内存中运行。

   三大类加载器:

        BootStrap:        jre/lib/rt.jar

        ExtClassLoader: jre/lib/ext/.*.jar ,文件

        AppClassLoader(系统默认的类加载器):classPath下的类文件或目录

   类加载器的委托机制:

       每个类加载器加载类时,又先委托给其上级类加载器。--load方法

       (如果类A中引用了类B,Java虚拟机将使用加载类A的类装载器来加载类B)

       双亲委派机制:如果load方法找不到时,则用find方法找。好处:没有重名的类加载上

3.代理

   静态代理:Thread采用了静态代理,Runnable是target,Thread是代理类,new Thread(Runnable target),将target交给代理类Thread执行。

   动态代理:好处是可以在运行期动态生成出类的字节码,不需要为每个类配置静态代理的功能。

   使用案例:

package cn.itcast.day3;

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

public class ProxyTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		//生成代理类
		Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
		
		
		final ArrayList target = new ArrayList();
		//根据target:ArrayList,和接口:Advice,创建一个代理类对象出来,该代理只关心target接口的方法,所以选择它的接口
		Collection proxy3 = (Collection)getProxy(target,new MyAdvice());
		proxy3.add("zxx");
		proxy3.add("lhm");
		proxy3.add("bxd");
		System.out.println(proxy3.size());
		System.out.println(proxy3.getClass().getName());
	}
     //根据target:ArrayList,和接口:Advice,创建一个代理类对象出来
	private static Object getProxy(final Object target,final Advice advice) {
		Object proxy3 = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				/*new Class[]{Collection.class},*/
				target.getClass().getInterfaces(), //获取target的接口,原因是代理类要调用target的方法,但是不关心具体内容,所以使用它的接口
				new InvocationHandler(){
				
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {

						/*long beginTime = System.currentTimeMillis();
						Object retVal = method.invoke(target, args);
						long endTime = System.currentTimeMillis();
						System.out.println(method.getName() + " running time of " + (endTime - beginTime));
						return retVal;*/
						

						advice.beforeMethod(method);//方法之前的操作
						Object retVal = method.invoke(target, args);//调用目标类的方法
						advice.afterMethod(method);//方法之后的操作
						return retVal;						
						
					}
				}
				);
		return proxy3;
	}

}

4.线程篇

  4.1 ThreadLocal

                          对于多线程资源共享的问题,同步机制采用了“以时间换空间”的方式,而ThreadLocal采用了“以空间换时间”的方式。                      

                          在同步机制中,通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的,

                          使用同步机制要求程序慎密地分析什么时候对变量进行读写,什么时候需要锁定某个对象,什么时候释放对象锁等繁杂的问题,程序设计和编写难度相对较大。

                          而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本,从而隔离了多个线程对数据的访问冲突。

                          因为每一个线程都拥有自己的变量副本,从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象,在编写多线程代码时,可以把不安全的变量封装进ThreadLocal。

   4.2 线程池

         ExecutorService:Executors.newCachedThreadPool(),Executors.newFixedThreadPool(int nThreads),Executors.newSingleThreadExecutor()

         作用:在线程池的编程模式下,任务是提交给整个线程池,而不是直接交给某个线程,线程池在拿到任务后,

                 它就在内部找有无空闲的线程,再把任务交给内部某个空闲的线程,这就是封装。记住,任务是提交给整个线程池,一个线程同时只能执行一个任务,但可以同时向一个线程池提交多个任务。

   4.3 Callable&Future

         作用:好比我同时种了几块地的麦子,然后就等待收割。收割时,则是那块先成熟了,则先去收割哪块麦子。

   4.4 Lock&Condition
          Lock:将“锁”的功能从“对象锁”中抽离出来,形成一个与对象无关,独立功能的锁。

          condition:将对象中的等待,唤醒方法抽离出来,弄成一个condition条件的形式控制对象线程的等待,唤醒操作。

   4.5 Semaphore

          作用:Semaphore 通常用于限制可以访问某些资源(物理或逻辑的)的线程数目。

          形式:Semaphore(int permits),permits为固定的许可证数量,只有的到了“许可证”才可以执行任务,执行完任务后释放“许可证”

   4.6 其他同步工具类

    CyclicBarrier :表示大家彼此等待,大家集合好后才开始出发,分散活动后又在指定地点集合碰面,这就好比整个公司的人员利用周末时间集体郊游一样,

           先各自从家出发到公司集合后,再同时出发到公园游玩,在指定地点集合后再同时开始就餐,…。

           CountDownLatch: 犹如倒计时计数器,调用CountDownLatch对象的countDown方法就将计数器减1,当计数到达0时,则所有等待者或单个等待者开始执行。

                                     这直接通过代码来说明CountDownLatch的作用,这样学员的理解效果更直接。 可以实现一个人(也可以是多个人)等待其他所有人都来通知他,

                                     这犹如一个计划需要多个领导都签字后才能继续向下实施。还可以实现一个人通知多个人的效果,类似裁判一声口令,运动员同时开始奔跑。用这个功能做百米赛跑的游戏程序不错哦!              Exchanger: 用于实现两个人之间的数据交换,每个人在完成一定的事务后想与对方交换数据,第一个先拿出数据的人将一直等待第二个人拿着数据到来时,才能彼此交换数据

    4.7 可阻塞的队列    

         ArrayBlockingQueue 只有put方法和take方法才具有阻塞功能

         BlockingQueue: 实现主要用于生产者-使用者队列

         BlockingQueuez: 实现是线程安全的

    作用:部分线程负责生产线,生产的产品数量固定,生产足够后,等待部分线程负责消费,然后生产线在补充生产,如此下去

class Producer implements Runnable {
   private final BlockingQueue queue;
   Producer(BlockingQueue q) { queue = q; }
   public void run() {
     try {
       while(true) { queue.put(produce()); }
     } catch (InterruptedException ex) { ... handle ...}
   }
   Object produce() { ... }
 }

 class Consumer implements Runnable {
   private final BlockingQueue queue;
   Consumer(BlockingQueue q) { queue = q; }
   public void run() {
     try {
       while(true) { consume(queue.take()); }
     } catch (InterruptedException ex) { ... handle ...}
   }
   void consume(Object x) { ... }
 }

 class Setup {
   void main() {
     BlockingQueue q = new SomeQueueImplementation();
     Producer p = new Producer(q);
     Consumer c1 = new Consumer(q);
     Consumer c2 = new Consumer(q);
     new Thread(p).start();
     new Thread(c1).start();
     new Thread(c2).start();
   }
 }