SoftReference<String[]> softBean = 
	new SoftReference<String[]>(new String[]{"a", "b", "c"});

WeakReference <String[]> weakBean = 
	new WeakReference<String[]>(new String[]{"a", "b", "c"});

/**
 * 类<code>Doc</code>用于：TODO
 *
 * @author ${USER}
 * @version 1.0
 * @date ${YEAR}-${MONTH}-${DAY}
 */

**
 * 方法<code>$methodName$</code>作用为：
 *
 * @author $author$
 * $params$ 
 * @throws $throws$
 * @return $return$
 */

**
 * 类<code>$className$</code>用于：TODO
 *
 * @author $USER$
 * @version 1.0
 * @date $date$
 */

@WebService
@SOAPBinding(style = SOAPBinding.Style.RPC)
public interface testWebservice {
  
  @WebMethod
    public ResponseRoot test(@WebParam(name = "item") Item item, 
                             @WebParam(name = "MessageHeader") MessageHeaderRoot header) ;

}

@XmlRootElement(name = "MessageHeader")
public class MessageHeaderRoot implements Serializable {

    private static final long serialVersionUID = 1848365930921924635L;

    @XmlElement(name = "GUID")
    private String guid;
    @XmlElement(name = "SEND_DATE")
    private String sendDate;
    @XmlTransient
    public String getGuid() {
        return guid;
    }

    public void setGuid(String guid) {
        this.guid = guid;
    }
 
    @XmlTransient
    public String getSendDate() {
        return sendDate;
    }

    public void setSendDate(String sendDate) {
        this.sendDate = sendDate;
    }
}

ResQuestionBean resQuestionBean = new ResQuestionBean();
resQuestionBean.setQuestionCode(questionCode);
resQuestionBean.setQuestionStatus(statusName);
resQuestionBean.setUploader(personCode);
resQuestionBean.setUploaderTime(DateUtil.format(new Date()));
StringBuilder resultXml = new StringBuilder();
resultXml.append(XmlUtils.objectToXML(resQuestionBean));

public static String objectToXML(Object object) throws JAXBException {
  JAXBContext context = JAXBContext.newInstance(object.getClass());
  Marshaller m = context.createMarshaller();
  // 设置格式化输出
  m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
  m.setProperty(Marshaller.JAXB_FRAGMENT, true);
  // 不进行转义字符的处理
  m.setProperty(CharacterEscapeHandler.class.getName(), new CharacterEscapeHandler() {
    @Override
    public void escape(char[] ch, int start,int length, boolean isAttVal, Writer writer) throws IOException {
      writer.write(ch, start, length);
    }
  });
  Writer w = new StringWriter();
  m.marshal(object, w);
  return w.toString();
}

private synchronized String doSend(String address, String invokeMethod, 
                                   String guid, String recvSys, 
                                   String invokeDate, String dataXml) throws IOException {
  //enum 选择系统，地址url  http post方式
  StringBuffer strBuf = null;
  URL url = new URL(address);
  HttpURLConnection huc = (HttpURLConnection) url.openConnection();
  huc.setRequestMethod("POST");
  //设置数据格式
  huc.setRequestProperty("content-type", "text/xml;charset=utf-8");
  huc.setConnectTimeout(10000);
  huc.setUseCaches(false);
  huc.setReadTimeout(10000);
  huc.setDoInput(true);
  huc.setDoOutput(true);
  huc.setInstanceFollowRedirects(false);
  DataOutputStream dos = new DataOutputStream(huc.getOutputStream());
  dos.write(buildSendXml(invokeMethod, guid, recvSys, invokeDate, dataXml).getBytes("utf-8"));

  dos.flush();
  BufferedReader reader = new BufferedReader(new InputStreamReader(huc.getInputStream(), "utf-8"));
  String line = null;
  strBuf = new StringBuffer();
  while ((line = reader.readLine()) != null) {
    strBuf.append(line);
  }
  dos.close();
  reader.close();
  return strBuf.toString();
}

private String buildSendXml(String invokeMethod, String guid, 
                            String invokeDate,
                            String data, String itemTag, String methodTag) {
  StringBuffer sb = new StringBuffer();
  sb.append("<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:urn=\"urn:sap-com:document:sap:rfc:functions\">" +
            "<soapenv:Header/>" +
            "<soapenv:Body>" +
            "<" + methodTag + ":" + invokeMethod + ">" +
            "   <MessageHeader>" +
            "      <GUID>" + guid + "</GUID>" +
            "      <SEND_DATE>" + invokeDate + "</SEND_DATE>" +
            "   </MessageHeader>" +
            "      <" + itemTag + ">");
  sb.append(data);
  sb.append("    <" + itemTag + ">" +
            "</urn:" + invokeMethod + "> " +
            "  </soapenv:Body>" +
            "</soapenv:Envelope>");
  return sb.toString();
}

public static void main(String[] args) {
    AtomicInteger integer = new AtomicInteger(2);
    integer.incrementAndGet();
}
public final int incrementAndGet() {    
	for (;;) {
	    int current = get();
	    int next = current + 1; 
	    if (compareAndSet(current, next))
	    return next;    
	}
}
public final boolean compareAndSet(int expect, int update) {
   return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

compareAndSwapInt(this, valueOffset, expect, update){
	if (this == expect) {
		this = update
		return true;
	} else {
		return false;
	}
}

private void useCountDownLatch(){
    Thread[] threads = new Thread[10];
    // set countDownLatch size
    CountDownLatch countDownLatch = new CountDownLatch(10);

    for (int i = 0; i < 10; i++) {
        threads[i] =  new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(getName());
                    countDownLatch.countDown();
                }
            }
        };
        threads[i].setName("thread-"+i);
        // execute Thread run then countDown..
    }

    for (int i = 0; i < threads.length; i++) {
        threads[i].start();
    }
    System.out.println("Task Start!");

    try{
        // causes current thread wait until the countDownLatch down to zero
        // effect all thread finish run()
        countDownLatch.await();
    }catch (Exception e){

    }

    System.out.println("All Task is Done!");
}

Task Start!
thread-1
thread-3
thread-4
thread-0
thread-6
thread-2
thread-5
thread-9
thread-8
thread-7
All Task is Done!

public class JUC03_ReadWriteLock {

    static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private Integer msg = 0;

    public /*synchronized*/ void read(){
        Lock read = readWriteLock.readLock();
        try {
            read.lock();
            System.out.println("reading msg is "+msg);
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            read.unlock();
        }
    }

    public /*synchronized*/ void write(){
        Lock write = readWriteLock.writeLock();
        try{
            write.lock();
            msg = new Random().nextInt();
            System.out.println("write msg .."+ msg);
            Thread.sleep(1000);
        }catch (Exception e){

        }finally {
            write.unlock();
        }
    }

    public static void main(String[] args) {
        JUC03_ReadWriteLock juc03_readWriteLock = new JUC03_ReadWriteLock();

        for (int i = 0; i < 9; i++) {
            Thread readThread = new Thread(() -> {
                juc03_readWriteLock.read();
            });
            readThread.start();
        }

        for (int i = 0; i < 2; i++) {
            Thread writeThread = new Thread(()->{
                juc03_readWriteLock.write();
            });
            writeThread.start();
        }
    }
}

public class JUC03_Semaphore {

    Semaphore semaphore = new Semaphore(2);

    Thread t1 = new Thread(() -> {
        try {
            semaphore.acquire();
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            semaphore.release();
        }
        System.out.println("t1.....end");
    });

    Thread t2 = new Thread(() -> {
        try {
            semaphore.acquire();
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            semaphore.release();
        }
        System.out.println("t2.....end");
    });

    Thread t3 = new Thread(() -> {
        try {
            semaphore.acquire();
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            semaphore.release();
        }
        System.out.println("t3.....end");
    });

    public void run(){
        t1.start();
        t2.start();
        t3.start();
    }

    public static void main(String[] args) {
        JUC03_Semaphore juc03_semaphore = new JUC03_Semaphore();
        juc03_semaphore.run();
    }
}

public class JUC04_StopOtherThread01 {

    private int number = 0;

    public synchronized void intercept() {
        if (number != 5) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("print that message !!!");
        this.notify();
        try {
            this.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("intercept finished!!");
    }

    public synchronized void increase() {
        while (number <= 10) {
            if (number == 5) {
                this.notify();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            number++;
            System.out.println("current number size is :" + number);
        }
        this.notify();
    }

    public static void main(String[] args) {
        JUC04_StopOtherThread01 stopOtherThread01 = new JUC04_StopOtherThread01();
        new Thread(() -> {
            stopOtherThread01.intercept();
        }).start();

        new Thread(() -> {
            stopOtherThread01.increase();
        }).start();
    }
}

public class JUC04_StopOtherThread02 {
    int number = 0;

    private void increase() {
        number++;
    }

    private int size() {
        return number;
    }

    public static void main(String[] args) {
        JUC04_StopOtherThread02 s = new JUC04_StopOtherThread02();

        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            try {
                lock.lock();
                if (s.size() != 5) {
                    condition.await();
                }
                System.out.println("print that message !!!");
                condition.signal();
                condition.await();
                System.out.println("all finished!!");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }).start();

        new Thread(() -> {
            try {
                lock.lock();
                while (s.size() < 10) {
                    if (s.size() == 5) {
                        condition.signal();
                        condition.await();
                    }
                    s.increase();
                    System.out.println("current number size is :" + s.size());
                }
                condition.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }).start();
    }
}

public class JUC04_StopOtherThread03 {
    int number = 0;

    private void increase() {
        number++;
    }

    private int size() {
        return number;
    }

    public static void main(String[] args) {
        JUC04_StopOtherThread03 s = new JUC04_StopOtherThread03();

        CountDownLatch latch1 = new CountDownLatch(1);
        CountDownLatch latch2 = new CountDownLatch(1);

        new Thread(() -> {
            try {
                if (s.size() != 5) {
                    latch1.await();
                    latch2.countDown();
                }
                System.out.println("print that message !!!");

                System.out.println("all finished!!");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
        }).start();

        new Thread(() -> {
            try {
                while (s.size() < 10) {
                    if (s.size() == 5) {
                        latch1.countDown();

                        latch2.await();
                    }
                    s.increase();
                    System.out.println("current number size is :" + s.size());
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }

        }).start();
    }
}

public class JUC04_StopOtherThread04 {
    int number = 0;

    Thread t1 = null;
    Thread t2 = null;

    private void increase() {
        number++;
    }

    private int size() {
        return number;
    }

    public static void main(String[] args) {

        JUC04_StopOtherThread04 s = new JUC04_StopOtherThread04();

        s.t1 = new Thread(() -> {
            try {
                if (s.size() != 5) {
                  LockSupport.park();
                  LockSupport.unpark(s.t2);
                }
                System.out.println("print that message !!!");

                System.out.println("all finished!!");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }
        });

        s.t2 = new Thread(() -> {
            try {
                while (s.size() < 10) {
                    if (s.size() == 5) {
                        LockSupport.unpark(s.t1);
                        LockSupport.park();
                    }
                    s.increase();
                    System.out.println("current number size is :" + s.size());
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
            }

        });

        s.t1.start();
        s.t2.start();
    }
}

public class JUC04_CustomerAndProducer01 {
    List<Integer> repostory = new LinkedList<>();
    private int size = 0;
    private int MAX = 15;

    public synchronized void add(Integer value) throws InterruptedException {
        while (size == MAX) {
            System.out.println(Thread.currentThread().getName() + " size:" + size + " block producer thread!!");
            this.wait();
        }
        repostory.add(value);
        size++;
        System.out.println("current thread "+Thread.currentThread().getName()+" increase size , current size is :" + size);
        this.notifyAll();
    }

    public synchronized void get() throws InterruptedException {
        while (size <= 0) {
            System.out.println(Thread.currentThread().getName() + " size:" + size + " block customer thread!!");
            this.wait();
        }
        repostory.remove(0);
        size--;
        System.out.println("current thread "+Thread.currentThread().getName()+" increase size , current size is :" + size);
        this.notifyAll();
    }

    public static void main(String[] args) {
        JUC04_CustomerAndProducer01 c = new JUC04_CustomerAndProducer01();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) {
                    try {
                        c.get();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "c_" + i).start();
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 25; j++) {
                    try {
                        c.add(new Random().nextInt());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "p_" + i).start();
        }

    }
}

public class JUC04_CustomerAndProducer02 {
    List<Integer> repostory = new LinkedList<>();
    private ReentrantLock lock = new ReentrantLock();
    private Condition add = lock.newCondition();
    private Condition get = lock.newCondition();

    private int size = 0;
    private int MAX = 15;

    public  void add(Integer value) throws InterruptedException {
        try {
            lock.lock();
            while (size == MAX) {
                System.out.println(Thread.currentThread().getName() + " size:" + size + " block producer thread!!");
                add.await();
            }
            repostory.add(value);
            size++;
            System.out.println("current thread "+Thread.currentThread().getName()+" increase size , current size is :" + size);
            get.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public  void get() throws InterruptedException {
        try{
            lock.lock();
            while (size <= 0) {
                System.out.println(Thread.currentThread().getName() + " size:" + size + " block customer thread!!");
                get.await();
            }
            repostory.remove(0);
            size--;
            System.out.println("current thread "+Thread.currentThread().getName()+" increase size , current size is :" + size);
            add.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    public static void main(String[] args) {
        JUC04_CustomerAndProducer02 c = new JUC04_CustomerAndProducer02();

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 5; j++) {
                    try {
                        c.get();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "c_" + i).start();
        }

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 25; j++) {
                    try {
                        c.add(new Random().nextInt());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "p_" + i).start();
        }
    }
}

/**
 * 1. 使用 @Aspect 注解创建切面类
 * 2. 使用 @Pointcut 注解注明切点（使用Aspect表达式）
 * 3. 声明通知（Before，After，Around，AfterReturning，AfterThrowing）具体含义可以参考Ref文档 5.4.4. Declaring Advice
 * 只是以上三步是不行的，因为没有开启Spring对注解版AOP的支持
 * 所以，需要使用 @EnableAspectJAutoProxy 开启对@Aspect注解的支持
 **/
@Aspect
@Component
public class LogAspects {

	@Pointcut(value="within(com.nanyin.service.*)")
// 	@Pointcut("execution(public * (..))")
	public void pointCut(){
	}

	@Before("pointCut()")
	public void logBefore(JoinPoint jp){
		System.out.println(jp.getSignature().getName());
		System.out.println("before...");
	}

	@After("pointCut()")
	public void logAfter(){
		System.out.println("after...");
	}

	@AfterReturning("pointCut()")
	public void logAfterReturn(){
		System.out.println("after return...");
	}

	@AfterThrowing(value = "pointCut()",throwing = "ex")
	public void logAfterThrowing(JoinPoint joinPoint,Exception ex){
		joinPoint.getSignature().getName();
		System.out.println("after throwing...");
		System.out.println(ex.getMessage());
	}
	// around在proceed 之前是在 before之前执行
	// around在proceed 之前是在 after之前执行
	// 可兼容before和after
	@Around("pointCut()")
	public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
		// 方法开始
		System.out.println("around methods begin ...");
		Object object = joinPoint.proceed();
		System.out.println("around methods end ...");
		return object;
	}
}

/**
 * 进行测试
 * 
 **/
@Test
public void test1(){
	AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(BasicConfig.class);
	BasicService basicService = (BasicService) applicationContext.getBean("basicService");
	// 因为切点包括这个basicService，所以执行hello就会触发AOP
	basicService.hello();
}

// 结果
around methods begin ...
hello
before...
hello world!!
around methods end ...
after...
after return...

@Target(ElementType.TYPE) //标注在类上
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class) //引入 AspectJAutoProxyRegistrar
public @interface EnableAspectJAutoProxy {
  /**
   * 是否使用CGLIB进行代理，默认是false，即默认使用JDK动态代理
   **/
  boolean proxyTargetClass() default false;
  /**
   * 是否需要 代理应由AOP框架公开为{ThreadLocal}，以便通过{AopContext}类进行检索。
   **/
  boolean exposeProxy() default false;
}

@Override
public void registerBeanDefinitions(
		AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
	//如果需要 注册AspectJ注解自动代理创建类 internalAutoProxyCreator
	AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
// 	...
}
	@Nullable
	public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
			BeanDefinitionRegistry registry, @Nullable Object source) {
		// 注册或升级AutoProxyCreator AnnotationAwareAspectJAutoProxyCreator 这个类是用来处理所有的AspectJ注解的切面
		return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
	}

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
		Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
//		cls=AnnotationAwareAspectJAutoProxyCreator
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	// 是否存在internalAutoProxyCreator
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
    // ...	
	}
	// 获得一个 AnnotationAwareAspectJAutoProxyCreator 的 beanDefinition
	RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
	beanDefinition.setSource(source);
	beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
	beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	// 注册名为 org.springframework.aop.config.internalAutoProxyCreator 的类
	// 实际对应的是 AnnotationAwareAspectJAutoProxyCreator 类，而这个类是用来使@Aspect起作用的
	registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
	return beanDefinition;
}

// postProcessBeforeInitialization ,BeanPostProcessor的实现方法。
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
	Object cacheKey = getCacheKey(beanClass, beanName); //获得beanClass

	if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
		if (this.advisedBeans.containsKey(cacheKey)) {
			return null;
		}
		if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
		  // 通过判断是否使用了@AspectJ注解定义的切面类还是 
      // 实现Advice、Pointcut、Advisor、AopInfrastructureBean
			this.advisedBeans.put(cacheKey, Boolean.FALSE); //添加到advisedBeans里面，等待处理
			return null;
		}
	}
	//如果不是基础设施的类
	TargetSource targetSource = getCustomTargetSource(beanClass, beanName); //获得targetSource
	if (targetSource != null) {
		if (StringUtils.hasLength(beanName)) {
			this.targetSourcedBeans.add(beanName);
		}
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
		Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource); //创建代理类
		this.proxyTypes.put(cacheKey, proxy.getClass());
		return proxy;
	}

	return null;
}

@Override
protected boolean isInfrastructureClass(Class<?> beanClass) {
  // 加上父类中的isInfrastructureClass判断规则
	return (super.isInfrastructureClass(beanClass) ||
			(this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
}
public boolean isAspect(Class<?> clazz) {
	return (hasAspectAnnotation(clazz) && !compiledByAjc(clazz));
}
// 在这里判断是否存在 Aspect 注解
private boolean hasAspectAnnotation(Class<?> clazz) {
  return (AnnotationUtils.findAnnotation(clazz, Aspect.class) != null);
}
// AbstractAutoProxyCreator 中的方法
protected boolean isInfrastructureClass(Class<?> beanClass) {
	boolean retVal = Advice.class.isAssignableFrom(beanClass) || //是否实现 Advice
			Pointcut.class.isAssignableFrom(beanClass) || //是否实现 Pointcut
			Advisor.class.isAssignableFrom(beanClass) || //是否实现 Advisor
			AopInfrastructureBean.class.isAssignableFrom(beanClass); //是否实现 AopInfrastructureBean
	if (retVal && logger.isTraceEnabled()) {
		logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
	}
	return retVal;
}

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
	if (bean != null) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		if (this.earlyProxyReferences.remove(cacheKey) != bean) { // 如果不存在
		// 如果需要进行代理的包装
			return wrapIfNecessary(bean, beanName, cacheKey);
		}
	}
	return bean;
}
//如有必要，包装给定的bean，即是否有资格被代理
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
	if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
		// 如果在 postProcessBeforeInitialization 中定义了targetSourcedBeans,则直接返回
		return bean;
	}
	if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
		// 如果已经添加到advisedBeans中也直接返回
		return bean;
	}
	// 如果是一个基本配置Aspect类，则放到advisedBeans中。
	if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

	// 创建Advice
	Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
	// Advice存在，则表示需要代理
	if (specificInterceptors != DO_NOT_PROXY) {
		this.advisedBeans.put(cacheKey, Boolean.TRUE);
		// 创建代理
		Object proxy = createProxy(
				bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
		this.proxyTypes.put(cacheKey, proxy.getClass());
		// 返回代理对象。
		return proxy;
	}

	this.advisedBeans.put(cacheKey, Boolean.FALSE);
	return bean;
}

List<String> aspectNames = this.aspectBeanNames;
		if (aspectNames == null) {
			synchronized (this) {
				aspectNames = this.aspectBeanNames;
				if (aspectNames == null) {
          // ....

List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);// 获取Aspect类中的Advice
  if (this.beanFactory.isSingleton(beanName)) {// 如果是单例的
    this.advisorsCache.put(beanName, classAdvisors);// advisorsCache 是以 BeanName为Key，List<Advice>为value的Map
  }

private List<Method> getAdvisorMethods(Class<?> aspectClass) {
	final List<Method> methods = new ArrayList<>();
	ReflectionUtils.doWithMethods(aspectClass, method -> {
		// Exclude pointcuts
		if (AnnotationUtils.getAnnotation(method, Pointcut.class) == null) { // 除去标注了Pointcut注解的方法 添加到 "method"中
			methods.add(method);
		}
	}, ReflectionUtils.USER_DECLARED_METHODS);
	methods.sort(METHOD_COMPARATOR);
	return methods;
}

protected static AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
		for (Class<?> clazz : ASPECTJ_ANNOTATION_CLASSES) {
			AspectJAnnotation<?> foundAnnotation = findAnnotation(method, (Class<Annotation>) clazz);
			if (foundAnnotation != null) {
				return foundAnnotation;
			}
		}
		return null;
	}

List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);// 获取Aspect类中的Advice
if (this.beanFactory.isSingleton(beanName)) {// 如果是单例的
  this.advisorsCache.put(beanName, classAdvisors);// advisorsCache 是以 BeanName为Key，List<Advice>为value的Map
}

// Create proxy if we have advice.
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
  this.advisedBeans.put(cacheKey, Boolean.TRUE);
  Object proxy = createProxy(
    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
  this.proxyTypes.put(cacheKey, proxy.getClass());
  return proxy;
}

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
   Assert.notNull(pc, "Pointcut must not be null");
   if (!pc.getClassFilter().matches(targetClass)) {
      return false;
   }
   // 使用Matcher进行类级别的匹配验证
   MethodMatcher methodMatcher = pc.getMethodMatcher();
   if (methodMatcher == MethodMatcher.TRUE) {
      // No need to iterate the methods if we're matching any method anyway...
      return true;
   }

// 如果存在可用的通知，则对Bean进行代理
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
	this.advisedBeans.put(cacheKey, Boolean.TRUE);
	// 创建代理对象
	Object proxy = createProxy(
			bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
	this.proxyTypes.put(cacheKey, proxy.getClass());
	return proxy;
}

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
		@Nullable Object[] specificInterceptors, TargetSource targetSource) {

	if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
		AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
	}

	ProxyFactory proxyFactory = new ProxyFactory();
	proxyFactory.copyFrom(this);// 复制配置

	if (!proxyFactory.isProxyTargetClass()) {//返回是否直接代理目标类以及任何接口。
		if (shouldProxyTargetClass(beanClass, beanName)) {
		// 如果 proxy-target-class 标签属性返回true，则表明需要基于类的代理，
		// 反之则需要基于接口的代理
			proxyFactory.setProxyTargetClass(true); //使用CGLIB代理（true）
		}else {
			evaluateProxyInterfaces(beanClass, proxyFactory); //检查是否实现了接口
			// 如果实现了接口，则设置interface，否则设置proxyTargetClass为true，但前提是
			// 用户没有自己设置proxyTargetClass属性
			/**
			 * if (hasReasonableProxyInterface) {
			 * Must allow for introductions; can't just set interfaces to the target's interfaces only.
			 *	for (Class<?> ifc : targetInterfaces) {
			 *		proxyFactory.addInterface(ifc);
			 *	}
		     *}else {
			 *	proxyFactory.setProxyTargetClass(true);
			 *}
			 */
		}
	}
	Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
	proxyFactory.addAdvisors(advisors);
	proxyFactory.setTargetSource(targetSource);
	customizeProxyFactory(proxyFactory);

	proxyFactory.setFrozen(this.freezeProxy);
	if (advisorsPreFiltered()) {
		proxyFactory.setPreFiltered(true);
	}

	return proxyFactory.getProxy(getProxyClassLoader());
}

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
	/*
	* 下面的三个条件简单分析一下：
	*
	*   条件1：config.isOptimize() - 是否需要优化
	*   条件2：config.isProxyTargetClass() - 检测 proxyTargetClass 的值，
	*   条件3：hasNoUserSuppliedProxyInterfaces(config) - 目标 bean 是否实现了接口
	*
	*/
	if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
		// 如果设置了optimize 或者 proxyTargetClass 或者设置了进行代理的接口
		Class<?> targetClass = config.getTargetClass();
		if (targetClass == null) {
			throw new AopConfigException("TargetSource cannot determine target class: " +
					"Either an interface or a target is required for proxy creation.");
		}
		if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
			return new JdkDynamicAopProxy(config); //如果代理的是接口，使用JDK动态代理
		}
		return new ObjenesisCglibAopProxy(config);//否则使用CGlib代理
	}
	else { //否则都使用JDK进行代理
		return new JdkDynamicAopProxy(config);
	}
}

@Component
public class Person {
	private String firstName;
	private String lastName;

 	public Person(String firstName, String lastName) {
		this.firstName = "w";
		this.lastName = "y";
	}

	@Autowired
	@Qualifier("abc")
	private Pet pet;
// 省略getter setter
}


// 或者在声明Bean时，使用Primary进行指定。
@Bean("dotdot")
@Primary
public Pet pet2(){
	return new Pet("dotdot");
}

@Component
public class Person {
	private String firstName;
	private String lastName;

	public Person(String firstName, String lastName) {
		this.firstName = "w";
		this.lastName = "y";
	}

	@Inject
	@Named("abc")
	private Pet pet;
	// 省略getter setter
}

public class SimpleMovieLister {
@Autowired public void setMovieFinder(@Nullable MovieFinder movieFinder) {
  ...
}

// 在dog实例中指定init和destroy方法
public class Dog {

    public void init(){
        System.out.println("instance dog execute init method.....");
    }

    public void destroy(){
        System.out.println("instance dog execute destroy method.....");
    }
}

// 声明bean的时候指定 initMethod = "init",destroyMethod = "destroy"
@Configurable
public class LifeCycleConfig {
    @Bean(initMethod = "init",destroyMethod = "destroy")
    public Dog dog(){
        System.out.println("begin create dog");
        return new Dog();
    }
}
// 执行测试
@Test
public void LifeCycleTest(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(LifeCycleConfig.class);
    System.out.println("instance has created !!!");
//        Dog dog = (Dog) applicationContext.getBean("dog");
    ((AnnotationConfigApplicationContext) applicationContext).close();
    System.out.println("context has closed !!!");
}

// 测试结果:
// begin create dog
// instance dog execute init method.....
// instance has created !!!
// instance dog execute destroy method.....
// context has closed !!!

public class Cat implements InitializingBean, DisposableBean {

//  接口中的destroy 方法,执行销毁bean
    public void destroy() throws Exception {
        System.out.println("instance cat execute destroy method.....");
    }
// 接口中的afterPropertiesSet方法,用来创建bean后的初始化
    public void afterPropertiesSet() throws Exception {
        System.out.println("instance cat execute init method.....");
    }
}

// 不需要在bean注解中指定相关方法
@Bean
public Cat cat(){
    System.out.println("begin create cat");
    return new Cat();
}

//用同样的测试程序测试得到的结果如下:
// begin create cat
// instance dog execute init method.....
// instance has created !!!
// instance dog execute destroy method.....
// context has closed !!!

public class Bug {

    @PostConstruct
    public void init(){
        System.out.println("instance Bug execute init method.....");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("instance Bug execute destroy method.....");
    }
}

public class MyBeanPostProcessor implements BeanPostProcessor {
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// 根据BeanName和bean可以获取bean的类信息接下来就可以进行筛选，在初始化前进行相关操作
		System.out.println(beanName);
		return null;
	}
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println(beanName);
		// 同理初始化后
		return null;
	}
}