dangelrose
dangelrose

Spring源码分析-配置文件加载流程

Spring配置文件加载流程

Spring配置文件是集成了Spring框架的项目的核心，引擎从哪里开始，中间都执行了哪些操作，小谈一下它的执行流程。

容器先是加载web .xml

 

接着是applicationContext.xml在web .xml里的注册

 

一种方法是加入ContextLoaderServlet这个servlet

Xml代码
  1. < context-param >   
  2.         < param-name > contextConfigLocation param-name >   
  3.         < param-value > /WEB -INF/applicationContext.xml param-value >   
  4.      context-param >   
  5.      < servlet >   
  6.         < servlet-name > context servlet-name >   
  7.         < servlet-class >   
  8.             org.springframework.web .context.ContextLoaderServlet  
  9.          servlet-class >   
  10.         < load-on-startup > 0 load-on-startup >   
  11.      servlet >    

		contextConfigLocation
		/WEB
-INF/applicationContext.xml
	
     
		context
		
			org.springframework.web
.context.ContextLoaderServlet
		
		0

还有一种是添加ContextLoaderListener这个监听器

Xml代码
  1. < context-param >   
  2.     < param-name > contextConfigLocation param-name >   
  3.     < param-value > /WEB -INF/applicationContext.xml param-value >   
  4. context-param >   
  5.   
  6. < listener >   
  7.     < listener-class > org.springframework.web .context.ContextLoaderListener listener-class >   
  8. listener >    

    contextConfigLocation
    /WEB
-INF/applicationContext.xml



    org.springframework.web
.context.ContextLoaderListener
 

 

下面是ContextLoaderServlet源代码

Java代码
  1. package  org.springframework.web .context;  
  2.   
  3. import  java.io.IOException;  
  4.   
  5. import  javax.servlet.ServletException;  
  6. import  javax.servlet.http.HttpServlet;  
  7. import  javax.servlet.http.HttpServletRequest;  
  8. import  javax.servlet.http.HttpServletResponse;  
  9.   
  10. public   class  ContextLoaderServlet  extends  HttpServlet {  
  11.   
  12.     private  ContextLoader  contextLoader ;  
  13.   
  14.   
  15.     /**  
  16.      * Initialize the root web  application context.  
  17.      */   
  18.   
  19. public   void  init()  throws  ServletException {  
  20.         this .contextLoader  = createContextLoader();  
  21.         this .contextLoader .initWebApplicationContext(getServletContext());  
  22.     }   /**  
  23.      * Create the ContextLoader  to use. Can be overridden in  subclasses.  
  24.      * @return the new ContextLoader  
  25.      */   
  26.     protected  ContextLoader  createContextLoader() {  
  27.         return   new  ContextLoader ();  
  28.     }  
  29.   
  30.     /**  
  31.      * Return the ContextLoader  used by this servlet.   
  32.      * @return the current ContextLoader  
  33.      */   
  34.     public  ContextLoader  getContextLoader() {  
  35.         return   this .contextLoader ;  
  36.     }  
  37.   
  38.   
  39.     /**  
  40.      * Close the root web  application context.  
  41.      */   
  42.     public   void  destroy() {  
  43.         if  ( this .contextLoader  !=  null ) {  
  44.             this .contextLoader .closeWebApplicationContext(getServletContext());  
  45.         }  
  46.     }  
  47.   
  48.   
  49.     /**  
  50.      * This should never even be called since no mapping to this servlet should  
  51.      * ever be created in  web .xml. That's why a correctly invoked Servlet 2.3  
  52.      * listener is much more appropriate for initialization work ;-)  
  53.      */   
  54.     public   void  service(HttpServletRequest request, HttpServletResponse response)  throws  IOException {  
  55.         getServletContext().log(  
  56.                 "Attempt to call service method on ContextLoaderServlet as ["  +  
  57.                 request.getRequestURI() + "] was ignored" );  
  58.         response.sendError(HttpServletResponse.SC_BAD_REQUEST);  
  59.     }  
  60.   
  61.   
  62.     public  String getServletInfo() {  
  63.         return   "ContextLoaderServlet for Servlet API 2.3 "  +  
  64.             "(deprecated in  favor of ContextLoaderListener for Servlet API 2.4)" ;  
  65.     }  
  66.   
  67. }   
package org.springframework.web
.context;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ContextLoaderServlet extends HttpServlet {

	private ContextLoader
 contextLoader
;


	/**
	 * Initialize the root web
 application context.
	 */

public void init() throws ServletException {
		this.contextLoader
 = createContextLoader();
		this.contextLoader
.initWebApplicationContext(getServletContext());
	}	/**
	 * Create the ContextLoader
 to use. Can be overridden in
 subclasses.
	 * @return the new ContextLoader

	 */
	protected ContextLoader
 createContextLoader() {
		return new ContextLoader
();
	}

	/**
	 * Return the ContextLoader
 used by this servlet. 
	 * @return the current ContextLoader

	 */
	public ContextLoader
 getContextLoader() {
		return this.contextLoader
;
	}


	/**
	 * Close the root web
 application context.
	 */
	public void destroy() {
		if (this.contextLoader
 != null) {
			this.contextLoader
.closeWebApplicationContext(getServletContext());
		}
	}


	/**
	 * This should never even be called since no mapping to this servlet should
	 * ever be created in
 web
.xml. That's why a correctly invoked Servlet 2.3
	 * listener is much more appropriate for initialization work ;-)
	 */
	public void service(HttpServletRequest request, HttpServletResponse response) throws IOException {
		getServletContext().log(
				"Attempt to call service method on ContextLoaderServlet as [" +
				request.getRequestURI() + "] was ignored");
		response.sendError(HttpServletResponse.SC_BAD_REQUEST);
	}


	public String getServletInfo() {
		return "ContextLoaderServlet for Servlet API 2.3 " +
		    "(deprecated in
 favor of ContextLoaderListener for Servlet API 2.4)";
	}

}
 

ContextLoaderListener源代码

Java代码
  1. package  org.springframework.web .context;  
  2.   
  3. import  javax.servlet.ServletContextEvent;  
  4. import  javax.servlet.ServletContextListener;  
  5.   
  6. public   class  ContextLoaderListener  implements  ServletContextListener {  
  7.   
  8.     private  ContextLoader  contextLoader ;  
  9.   
  10.   
  11.     /**  
  12.      * Initialize the root web  application context.  
  13.      */   
  14.     public   void  contextInitialized(ServletContextEvent event) {  
  15.                this .contextLoader  = createContextLoader();  
  16.         this .contextLoader .initWebApplicationContext(event.getServletContext());  
  17.     }  
  18.   
  19.     /**  
  20.      * Create the ContextLoader  to use. Can be overridden in  subclasses.  
  21.      * @return the new ContextLoader  
  22.      */   
  23.     protected  ContextLoader  createContextLoader() {  
  24.         return   new  ContextLoader ();  
  25.     }  
  26.   
  27.     /**  
  28.      * Return the ContextLoader  used by this listener.  
  29.      * @return the current ContextLoader  
  30.      */   
  31.     public  ContextLoader  getContextLoader() {  
  32.         return   this .contextLoader ;  
  33.     }  
  34.   
  35.   
  36.     /**  
  37.      * Close the root web  application context.  
  38.      */   
  39.     public   void  contextDestroyed(ServletContextEvent event) {  
  40.         if  ( this .contextLoader  !=  null ) {  
  41.             this .contextLoader .closeWebApplicationContext(event.getServletContext());  
  42.         }  
  43.     }  
  44.   
  45. }   
package org.springframework.web
.context;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextLoaderListener implements ServletContextListener {

	private ContextLoader
 contextLoader
;


	/**
	 * Initialize the root web
 application context.
	 */
	public void contextInitialized(ServletContextEvent event) {
               this.contextLoader
 = createContextLoader();
		this.contextLoader
.initWebApplicationContext(event.getServletContext());
	}

	/**
	 * Create the ContextLoader
 to use. Can be overridden in
 subclasses.
	 * @return the new ContextLoader

	 */
	protected ContextLoader
 createContextLoader() {
		return new ContextLoader
();
	}

	/**
	 * Return the ContextLoader
 used by this listener.
	 * @return the current ContextLoader

	 */
	public ContextLoader
 getContextLoader() {
		return this.contextLoader
;
	}


	/**
	 * Close the root web
 application context.
	 */
	public void contextDestroyed(ServletContextEvent event) {
		if (this.contextLoader
 != null) {
			this.contextLoader
.closeWebApplicationContext(event.getServletContext());
		}
	}

}

 以上都提到了ContextLoader 这个类

Java代码
  1. package  org.springframework.web .context;  
  2.   
  3. public   class  ContextLoader  {  
  4.   
  5.     public   static   final  String CONTEXT_CLASS_PARAM =  "contextClass" ;  
  6.   
  7.     public   static   final  String CONFIG_LOCATION_PARAM =  "contextConfigLocation" ;  
  8.   
  9.        public   static   final  String LOCATOR_FACTORY_SELECTOR_PARAM =  "locatorFactorySelector" ;  
  10.   
  11.     public   static   final  String LOCATOR_FACTORY_KEY_PARAM =  "parentContextKey" ;  
  12.   
  13.     private   static   final  String DEFAULT_STRATEGIES_PATH =  "ContextLoader .properties" ;  
  14.   
  15.   
  16.     private   static   final  Properties defaultStrategies;  
  17.   
  18.     static  {  
  19.                 try  {  
  20.             ClassPathResource resource = new  ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader . class );  
  21.             defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);  
  22.         }  
  23.         catch  (IOException ex) {  
  24.             throw   new  IllegalStateException( "Could not load 'ContextLoader .properties': "  + ex.getMessage());  
  25.         }  
  26.     }  
  27.   
  28.   
  29.     private   static   final  Log logger = LogFactory.getLog(ContextLoader . class );  
  30.   
  31.     private   static   final  Map currentContextPerThread = CollectionFactory.createConcurrentMapIfPossible( 1 );  
  32.   
  33.     private  WebApplicationContext context;  
  34.   
  35.     private  BeanFactoryReference parentContextRef;  
  36.   
  37.     public  WebApplicationContext initWebApplicationContext(ServletContext servletContext)  
  38.   
  39.           throws  IllegalStateException, BeansException {  
  40.   
  41.         if  (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) !=  null ) {  
  42.             throw   new  IllegalStateException(  
  43.                     "Cannot initialize context because there is already a root application context present - "  +  
  44.                     "check  whether  you  have  multiple  ContextLoader * definitions  in  your  web .xml!" );  
  45.         }  
  46.   
  47.         servletContext.log("Initializing Spring root WebApplicationContext" );  
  48.         if  (logger.isInfoEnabled()) {  
  49.             logger.info("Root WebApplicationContext: initialization started" );  
  50.         }  
  51.         long  startTime = System.currentTimeMillis();  
  52.   
  53.         try  {  
  54.             // Determine parent for root web  application context, if any.   
  55.             ApplicationContext parent = loadParentContext(servletContext);  
  56.   
  57.             // Store context in  local instance variable, to guarantee that   
  58.             // it is available on ServletContext shutdown.   
  59.             this .context = createWebApplicationContext(servletContext, parent);  
  60.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this .context);  
  61.             currentContextPerThread.put(Thread.currentThread().getContextClassLoader(), this .context);  
  62.   
  63.             if  (logger.isDebugEnabled()) {  
  64.                 logger.debug("Published root WebApplicationContext as ServletContext attribute with name ["  +  
  65.                         WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]" );  
  66.             }  
  67.             if  (logger.isInfoEnabled()) {  
  68.                 long  elapsedTime = System.currentTimeMillis() - startTime;  
  69.                 logger.info("Root WebApplicationContext: initialization completed in  "  + elapsedTime +  " ms" );  
  70.             }  
  71.   
  72.             return   this .context;  
  73.         }  
  74.         catch  (RuntimeException ex) {  
  75.             logger.error("Context initialization failed" , ex);  
  76.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);  
  77.             throw  ex;  
  78.         }  
  79.         catch  (Error err) {  
  80.             logger.error("Context initialization failed" , err);  
  81.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);  
  82.             throw  err;  
  83.         }  
  84.     }  
  85.   
  86.     protected  WebApplicationContext createWebApplicationContext(  
  87.             ServletContext servletContext, ApplicationContext parent) throws  BeansException {  
  88.   
  89.         Class contextClass = determineContextClass(servletContext);  
  90.         if  (!ConfigurableWebApplicationContext. class .isAssignableFrom(contextClass)) {  
  91.             throw   new  ApplicationContextException( "Custom context class ["  + contextClass.getName() +  
  92.                     "] is not of type ["  + ConfigurableWebApplicationContext. class .getName() +  "]" );  
  93.         }  
  94.   
  95.         ConfigurableWebApplicationContext wac =  
  96.                 (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);  
  97.         wac.setParent(parent);  
  98.         wac.setServletContext(servletContext);  
  99.         "color: rgb(0, 0, 0);" >wac.setConfigLocation(servletContext.getInitParameter(CONFIG_LOCATION_PARAM));  
  100.   
  101.   
  102.   
  103.   
  104.   
  105.   
  106. customizeContext(servletContext, wac);  
  107.         wac.refresh();  
  108.   
  109.         return  wac;  
  110.     }  
  111.   
  112.         protected  Class determineContextClass(ServletContext servletContext)  throws  ApplicationContextException {  
  113.         String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);  
  114.         if  (contextClassName !=  null ) {  
  115.             try  {  
  116.                 return  ClassUtils.forName(contextClassName);  
  117.             }  
  118.             catch  (ClassNotFoundException ex) {  
  119.                 throw   new  ApplicationContextException(  
  120.                         "Failed to load custom context class ["  + contextClassName +  "]" , ex);  
  121.             }  
  122.         }  
  123.         else  {  
  124.             contextClassName = defaultStrategies.getProperty(WebApplicationContext.class .getName());  
  125.             try  {  
  126.                 return  ClassUtils.forName(contextClassName, ContextLoader . class .getClassLoader());  
  127.             }  
  128.             catch  (ClassNotFoundException ex) {  
  129.                 throw   new  ApplicationContextException(  
  130.                         "Failed to load default context class ["  + contextClassName +  "]" , ex);  
  131.             }  
  132.         }  
  133.     }  
  134.   
  135.         protected   void  customizeContext(  
  136.             ServletContext servletContext, ConfigurableWebApplicationContext applicationContext) {  
  137.     }  
  138.   
  139.     protected  ApplicationContext loadParentContext(ServletContext servletContext)  
  140.             throws  BeansException {  
  141.   
  142.         ApplicationContext parentContext = null ;  
  143.         String locatorFactorySelector = servletContext.getInitParameter(LOCATOR_FACTORY_SELECTOR_PARAM);  
  144.         String parentContextKey = servletContext.getInitParameter(LOCATOR_FACTORY_KEY_PARAM);  
  145.   
  146.         if  (parentContextKey !=  null ) {  
  147.             // locatorFactorySelector may be null, indicating the default "classpath*:beanRefContext.xml"   
  148.             BeanFactoryLocator locator = ContextSingletonBeanFactoryLocator.getInstance(locatorFactorySelector);  
  149.             if  (logger.isDebugEnabled()) {  
  150.                 logger.debug("Getting parent context definition: using parent context key of '"  +  
  151.                         parentContextKey + "' with BeanFactoryLocator" );  
  152.             }  
  153.             this .parentContextRef = locator.useBeanFactory(parentContextKey);  
  154.             parentContext = (ApplicationContext) this .parentContextRef.getFactory();  
  155.         }  
  156.   
  157.         return  parentContext;  
  158.     }  
  159.   
  160.     public   void  closeWebApplicationContext(ServletContext servletContext) {  
  161.         servletContext.log("Closing Spring root WebApplicationContext" );  
  162.         try  {  
  163.             if  ( this .context  instanceof  ConfigurableWebApplicationContext) {  
  164.                 ((ConfigurableWebApplicationContext) this .context).close();  
  165.             }  
  166.         }  
  167.         finally  {  
  168.             currentContextPerThread.remove(Thread.currentThread().getContextClassLoader());  
  169.             servletContext.removeAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);  
  170.             if  ( this .parentContextRef !=  null ) {  
  171.                 this .parentContextRef.release();  
  172.             }  
  173.         }  
  174.     }  
  175.   
  176.   
  177.     public   static  WebApplicationContext getCurrentWebApplicationContext() {  
  178.         return  (WebApplicationContext) currentContextPerThread.get(Thread.currentThread().getContextClassLoader());  
  179.     }  
  180.   
  181. }   
package org.springframework.web
.context;

public class ContextLoader
 {

	public static final String CONTEXT_CLASS_PARAM = "contextClass";

	public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";

       public static final String LOCATOR_FACTORY_SELECTOR_PARAM = "locatorFactorySelector";

	public static final String LOCATOR_FACTORY_KEY_PARAM = "parentContextKey";

	private static final String DEFAULT_STRATEGIES_PATH = "ContextLoader
.properties";


	private static final Properties defaultStrategies;

	static {
				try {
			ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader
.class);
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		}
		catch (IOException ex) {
			throw new IllegalStateException("Could not load 'ContextLoader
.properties': " + ex.getMessage());
		}
	}


	private static final Log logger = LogFactory.getLog(ContextLoader
.class);

	private static final Map currentContextPerThread = CollectionFactory.createConcurrentMapIfPossible(1);

	private WebApplicationContext context;

	private BeanFactoryReference parentContextRef;

	public WebApplicationContext initWebApplicationContext(ServletContext servletContext)

          throws IllegalStateException, BeansException {

		if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
			throw new IllegalStateException(
					"Cannot initialize context because there is already a root application context present - " +
					"check
 whether
 you
 have
 multiple
 ContextLoader
* definitions
 in
 your
 web
.xml!");
		}

		servletContext.log("Initializing Spring root WebApplicationContext");
		if (logger.isInfoEnabled()) {
			logger.info("Root WebApplicationContext: initialization started");
		}
		long startTime = System.currentTimeMillis();

		try {
			// Determine parent for root web
 application context, if any.
			ApplicationContext parent = loadParentContext(servletContext);

			// Store context in
 local instance variable, to guarantee that
			// it is available on ServletContext shutdown.
			this.context = createWebApplicationContext(servletContext, parent);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
			currentContextPerThread.put(Thread.currentThread().getContextClassLoader(), this.context);

			if (logger.isDebugEnabled()) {
				logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
						WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
			}
			if (logger.isInfoEnabled()) {
				long elapsedTime = System.currentTimeMillis() - startTime;
				logger.info("Root WebApplicationContext: initialization completed in
 " + elapsedTime + " ms");
			}

			return this.context;
		}
		catch (RuntimeException ex) {
			logger.error("Context initialization failed", ex);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
			throw ex;
		}
		catch (Error err) {
			logger.error("Context initialization failed", err);
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
			throw err;
		}
	}

	protected WebApplicationContext createWebApplicationContext(
			ServletContext servletContext, ApplicationContext parent) throws BeansException {

		Class contextClass = determineContextClass(servletContext);
		if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
			throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
					"] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
		}

		ConfigurableWebApplicationContext wac =
				(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
		wac.setParent(parent);
		wac.setServletContext(servletContext);
		wac.setConfigLocation(servletContext.getInitParameter(CONFIG_LOCATION_PARAM));







customizeContext(servletContext, wac);
		wac.refresh();

		return wac;
	}

		protected Class determineContextClass(ServletContext servletContext)

你可能感兴趣的:(JAVA-EE-Spring)

  • HQL之投影查询 归来朝歌 HQLHibernate查询语句投影查询
            在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？ 针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
  • Spring整合redis bylijinnan redis
    pom.xml <dependencies> <!-- Spring Data - Redis Library --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
  • org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
    参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2         在项目中出现了org.hiber
  • android动画效果 不懂事的小屁孩 android动画
    前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。 一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。 第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
  • js delete 删除机理以及它的内存泄露问题的解决方案 换个号韩国红果果 JavaScript
    delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露  （其实还未删除） 举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
  • Oracle将零干预分析加入网络即服务计划 蓝儿唯美 oracle
    由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
  • spring学习——springmvc（二） a-john springMVC
    Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
  • POJ-2828-Buy Tickets aijuans ACM_POJ
    POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
  • Java Ant build.xml详解 asia007 build.xml
    1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台   --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
  • android按钮监听器的四种技术 百合不是茶 androidxml配置监听器实现接口
    android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方;    1,activity中使用内部类实现接口 ,创建内部类实例  使用add方法  与java类似   创建监听器的实例 myLis lis = new myLis();   使用add方法给按钮添加监听器  
  • 软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
            本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。         如今很多的公司
  • TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForgeHow doAttachementAnchorWiki Syntax
    the CollabNet user information center http://help.collab.net/   How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
  • 【Redis四】Redis数据类型 bit1129 redis
    概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
  • SSH2整合-附源码 白糖_ eclipsespringtomcatHibernateGoogle
    今天用eclipse终于整合出了struts2+hibernate+spring框架。 我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。     补充1：项目中部分jar包不是最新版的，可能导
  • [转]开源项目代码的学习方法 braveCS 学习方法
    转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html   1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
  • 编程之美-子数组的最大和（二维） bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美 子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
  • 读书笔记-3 chengxuyuancsdn jquery笔记resultMap配置ibatis一对多配置
    1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置 当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
  • [物理与天文]物理学新进展 comsci
          如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境       怎么办呢?  
  • Oracle 11g新特性:Automatic Diagnostic Repository daizj oracleADR
    Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。 在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。 这两份log文
  • 简单排序:选择排序 dieslrae 选择排序
    public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
  • C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
    示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
  • php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
    php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php  -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
  • 线程同步工具类 shuizhaosi888 同步工具类
    同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）   闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
  • bleeding edge是什么意思 haojinghua DI
    不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。  我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。   In computer science, bleeding edge is a term that
  • c中实现utf8和gbk的互转 jimmee ciconvutf8&gbk编码
    #include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
  • 大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
    1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。 应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
  • 在代码中获取Android theme中的attr属性值 OliveExcel androidtheme
    Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西.   在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
  • 基于Zookeeper的分布式共享锁 roadrunners zookeeper分布式共享锁
    首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。   共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。   官
  • 两个容易被忽略的MySQL知识 tomcat_oracle mysql
    1、varchar(5)可以存储多少个汉字，多少个字母数字？ 　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。 　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
  • zoj 3827 Information Entropy(水题) 阿尔萨斯 format
    题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。 解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他