dylanduk
dylanduk

Scope实现原理

[size=medium]内置Scope分类
Singleton 每个IOC容器对一个bean定义创建唯一实例
Prototype 对一个bean定义，每次请求容器都会创建新的实例
Request 对一个bean定义，一次web请求会创建一个实例
Session 对一个bean定义，一次web会话创建一个实例
Global Session 对一个bean定义，一次porlet会话创建一个实例
后三种只在Web环境下使用，AbstractApplicationContext refresh入口
[img]http://dl2.iteye.com/upload/attachment/0086/2360/64e104ec-5c07-3729-83b8-891845a4e2a8.jpg[/img]
AbstractRefreshableWebApplicationContext会注册这三种BEAN

[img]http://dl2.iteye.com/upload/attachment/0086/2362/dde430a8-6eda-38e2-90f5-a19198fe9062.jpg[/img]
WebApplicationContextUtils具体代码

[img]http://dl2.iteye.com/upload/attachment/0086/2366/730c2033-47aa-3b6d-b094-b9b9ffc010cc.jpg[/img]

当使用AbstractRefreshableWebApplicationContext并不会注册这三种Bean.
这三种Scope父类方法调用RequestContextHolder

[img]http://dl2.iteye.com/upload/attachment/0086/2377/ffe9d2b8-e454-38e7-af7e-3aef4b4a1751.jpg[/img]
在RequestContextHolder实现中，RequestAttribute为空，则抛出错误

[img]http://dl2.iteye.com/upload/attachment/0086/2379/d7b19745-e5d4-38d6-8198-8a3d02da54cd.jpg[/img]

RequestAttribute的实现ServletRequestAttributes中，封装了HTTP对象和Scope的Bean获取，设置和销毁方法

[img]http://dl2.iteye.com/upload/attachment/0086/2381/1460bc34-7b9e-3824-bf1a-2bf36f396475.jpg[/img]

[img]http://dl2.iteye.com/upload/attachment/0086/2387/340eebad-5a76-3cca-b111-21e66d93437b.jpg[/img]

[img]http://dl2.iteye.com/upload/attachment/0086/2389/fc7b9d7d-8f1d-3dda-8ce6-984fb423b43d.jpg[/img]

所以在WEB环境下，如果使用SPRING MVC,则在 DispatcherServlet, or DispatcherPortlet已经初始化RequestAttribute对象，否则必须做相关配置以初始化。
使用servlet2.4+容器，web.xml配置如下[/size] 

...

  
      org.springframework.web.context.request.RequestContextListener
  

...

[size=medium]servlet2.3,web配置如下[/size] 

..

  requestContextFilter
  org.springframework.web.filter.RequestContextFilter


  requestContextFilter
  /*

...


[size=medium]RequestContextFilter初始化RequestAtrributes[/size][img]http://dl2.iteye.com/upload/attachment/0086/2391/e7c53c34-430a-3f61-8054-67ce78889190.jpg[/img]

[size=medium]
Scope只有在getBean中有效
Spring不仅负责Bean的实例化，而且还管理依赖关系，根据依赖仅仅会在第一次请求时创建和装配好bean。因此：如果在bean定义中只是指定了scope，则除了singleton，其他的scope定义的bean实例的含义是无效的，必须钩入向Spring容器请求，也就是调用getBean方法。换句话说，我们必须改变依赖关系的注入。可以想到使用代理作为被注入的对象，当调用代理方法时，会实时的getBean 请求容器。实现这种机制的是 [/size] 


     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd">


[size=medium]我们插入了元素在被注入的userPreferences定义中，为什么scope等于request,session, global session,或自定义的scope bean需要这样？对比下面的定义[/size]


[size=medium]上面的例子中userManager被注入了一个scope等于HTTP session的bean userPreferences.userManager是单例的，它只会在每个容器中初始化一次，他所依赖的Bean也只会初始化一次。就是说userManager只会在一个userPreferences上操作，就是在第一次初始化的userPreferences上。
把生命周期短的注入到生命周期长的bean，可能不是想要的结果，就比如把session scope的bean注入到一个单例Bean中。你需要单例Bean负责Http session bean的特定于Http Session生命周期。因此容器创建了userPreferences的代理对象，把它注入到userManager，但userManager并不知道userPreferences是个代理对象。当userManager调用userPreferences实例的方法时，其实调用的是代理对象的方法。代理对象会请求真正的Bean并调用之上的方法。
同时可以选择创建代理的方式 JDK接口或CGLIB类方式，MethodInjection之中有讨论。默认情况下会使用CGLIB方式，如果想使用JDK动态代理，则作如下配置。[/size]


[size=medium]ScopedProxyFactoryBean实现
spring-beans DTD 或者 XSD的解析者DefaultBeanDefinitionDocumentReader
解析根元素及代理BeanDefinitionParserDelegate解析其他的子元素
根元素有beans，alias，import[/size] 

/**
	 * Parse the elements at the root level in the document:
	 * "import", "alias", "bean".
	 * @param root the DOM root element of the document
	 */
	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		if (delegate.isDefaultNamespace(root)) {
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				if (node instanceof Element) {
					Element ele = (Element) node;
					if (delegate.isDefaultNamespace(ele)) {
						parseDefaultElement(ele, delegate);
					}
					else {
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

[size=medium]子元素的解析者BeanDefinitionParserDelegate，当一个bean定义解析好之后，要进一步进行可能的自定义属性或内置元素的解析，进入decorateIfRequired方法。[/size]
[img]http://dl2.iteye.com/upload/attachment/0086/2450/f195d0e2-24e4-3964-96c5-8a8feaecb51d.jpg[/img]


[img]http://dl2.iteye.com/upload/attachment/0086/2454/7efb4629-738b-39c5-bd83-87577dd62566.jpg[/img]
[size=medium]
NamespaceHandler命名空间处理器，比如将使用AOPNamespaceHandler.
DefaultNamespaceHandlerResolver将会在所有的JAR包中查找META-INF/spring.handlers并读入，在JAR spring-aop下有META-INF/spring.handlers
内容为
http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler
在JAR spring-bean下有META-INF/spring.handlers，内容为
http\://www.springframework.org/schema/c=org.springframework.beans.factory.xml.SimpleConstructorNamespaceHandler
http\://www.springframework.org/schema/p=org.springframework.beans.factory.xml.SimplePropertyNamespaceHandler
http\://www.springframework.org/schema/util=org.springframework.beans.factory.xml.UtilNamespaceHandler
载入资源代码
[/size]
[img]http://dl2.iteye.com/upload/attachment/0086/2456/5cf8efb9-9009-3b9e-b313-a46b3662c23f.jpg[/img]
[size=medium]AopNamespaceHandler实现中可以看到config用于事务处理的；aspectj-autoproxy用于aspectj自动代理的；scoped-proxy用于Scope bean处理的；所以将由ScopedProxyBeanDefinitionDecorator处理[/size][img]http://dl2.iteye.com/upload/attachment/0086/2462/29f85e78-4d41-33f6-ae24-3e6273b024b0.jpg[/img]
[size=medium]ScopedProxyBeanDefinitionDecorator最终代理ScopedProxyUtils.createScopedProxy
1.创建一个ScopedProxyFactoryBean对应的代理RootBeanDefinition
2.占有了Scope bean的标识符，可能的候选者（当以类型装配查找时）
3.Scope bean的名字为标识符变成 "scopedTarget." + ID ,同时丧失候选资格[/size] 

String originalBeanName = definition.getBeanName();
		BeanDefinition targetDefinition = definition.getBeanDefinition();

		// Create a scoped proxy definition for the original bean name,
		// "hiding" the target bean in an internal target definition.
		RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
		proxyDefinition.setOriginatingBeanDefinition(definition.getBeanDefinition());
		proxyDefinition.setSource(definition.getSource());
		proxyDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

		String targetBeanName = getTargetBeanName(originalBeanName);
		proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);

		if (proxyTargetClass) {
			targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
			// ScopedFactoryBean's "proxyTargetClass" default is TRUE, so we don't need to set it explicitly here.
		}
		else {
			proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
		}

		// Copy autowire settings from original bean definition.
		proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
		proxyDefinition.setPrimary(targetDefinition.isPrimary());
		if (targetDefinition instanceof AbstractBeanDefinition) {
			proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
		}

		// The target bean should be ignored in favor of the scoped proxy.
		targetDefinition.setAutowireCandidate(false);
		targetDefinition.setPrimary(false);

		// Register the target bean as separate bean in the factory.
		registry.registerBeanDefinition(targetBeanName, targetDefinition);

		// Return the scoped proxy definition as primary bean definition
		// (potentially an inner bean).
		return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());

[size=medium]ScopedProxyFactoryBean实现
1.setProxyTargetClass设置代理方式,true为CGliB代理，false为JDK代理
2.scopedTargetSource = new SimpleBeanTargetSource()代理方法每调用一次，就会向Spring容器发送getBean请求
3.添加AopInfrastructureBean接口，生成代理对象；说明代理对象类型并不适合自动代理机制
4.添加DelegatingIntroductionInterceptor introduction借口，并暴露DefaultScopedObject对象，生成代理；所以可以编程式把代理对象转化ScopedObject对象而从scope中进行获取和移除bean[/size] 

/*
 * Copyright 2002-2009 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.aop.scope;

import java.lang.reflect.Modifier;

import org.springframework.aop.framework.AopInfrastructureBean;
import org.springframework.aop.framework.ProxyConfig;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;
import org.springframework.aop.target.SimpleBeanTargetSource;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.FactoryBeanNotInitializedException;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.util.ClassUtils;

/**
 * Convenient proxy factory bean for scoped objects.
 * 
 * 
Proxies created using this factory bean are thread-safe singletons
 * and may be injected into shared objects, with transparent scoping behavior.
 *
 * 
Proxies returned by this class implement the {@link ScopedObject} interface.
 * This presently allows for removing the corresponding object from the scope,
 * seamlessly creating a new instance in the scope on next access.
 * 
 * 
Please note that the proxies created by this factory are
 * class-based proxies by default. This can be customized
 * through switching the "proxyTargetClass" property to "false".
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 * @since 2.0
 * @see #setProxyTargetClass
 */
public class ScopedProxyFactoryBean extends ProxyConfig implements FactoryBean, BeanFactoryAware {

	/** The TargetSource that manages scoping */
	private final SimpleBeanTargetSource scopedTargetSource = new SimpleBeanTargetSource();

	/** The name of the target bean */
	private String targetBeanName;

	/** The cached singleton proxy */
	private Object proxy;


	/**
	 * Create a new ScopedProxyFactoryBean instance.
	 */
	public ScopedProxyFactoryBean() {
		setProxyTargetClass(true);
	}


	/**
	 * Set the name of the bean that is to be scoped.
	 */
	public void setTargetBeanName(String targetBeanName) {
		this.targetBeanName = targetBeanName;
		this.scopedTargetSource.setTargetBeanName(targetBeanName);
	}

	public void setBeanFactory(BeanFactory beanFactory) {
		if (!(beanFactory instanceof ConfigurableBeanFactory)) {
			throw new IllegalStateException("Not running in a ConfigurableBeanFactory: " + beanFactory);
		}
		ConfigurableBeanFactory cbf = (ConfigurableBeanFactory) beanFactory;

		this.scopedTargetSource.setBeanFactory(beanFactory);

		ProxyFactory pf = new ProxyFactory();
		pf.copyFrom(this);
		pf.setTargetSource(this.scopedTargetSource);

		Class beanType = beanFactory.getType(this.targetBeanName);
		if (beanType == null) {
			throw new IllegalStateException("Cannot create scoped proxy for bean '" + this.targetBeanName +
					"': Target type could not be determined at the time of proxy creation.");
		}
		if (!isProxyTargetClass() || beanType.isInterface() || Modifier.isPrivate(beanType.getModifiers())) {
			pf.setInterfaces(ClassUtils.getAllInterfacesForClass(beanType, cbf.getBeanClassLoader()));
		}

		// Add an introduction that implements only the methods on ScopedObject.
		ScopedObject scopedObject = new DefaultScopedObject(cbf, this.scopedTargetSource.getTargetBeanName());
		pf.addAdvice(new DelegatingIntroductionInterceptor(scopedObject));

		// Add the AopInfrastructureBean marker to indicate that the scoped proxy
		// itself is not subject to auto-proxying! Only its target bean is.
		pf.addInterface(AopInfrastructureBean.class);

		this.proxy = pf.getProxy(cbf.getBeanClassLoader());
	}


	public Object getObject() {
		if (this.proxy == null) {
			throw new FactoryBeanNotInitializedException();
		}
		return this.proxy;
	}

	public Class getObjectType() {
		if (this.proxy != null) {
			return this.proxy.getClass();
		}
		if (this.scopedTargetSource != null) {
			return this.scopedTargetSource.getTargetClass();
		}
		return null;
	}

	public boolean isSingleton() {
		return true;
	}

}

 
  
[size=medium]自定义scope 
  
编写了Scope实现之后，要将他注册到Spring容器中，下面是核心注册方法 
  
void registerScope(String scopeName, Scope scope); 
  
这个方法在ConfigurableBeanFactory中声明，大多数ApplicationContext都实现了它。 
  
方法中的第一个参数是scope的名字，用于配置bean指定scope时使用，第二个参数是具体实现。 
  
编程式的注册[/size] 
  
Scope threadScope = new SimpleThreadScope();
beanFactory.registerScope("thread", threadScope);
 
  
[size=medium]xml配置[/size] 
  
 
  
[size=medium]声明式注册 
  
 xml配置[/size] 
  

     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd">

  
      
          
              
                  
              
          
      
  

  
      
      
  

  
      
  

 
  
[size=medium] 实现 
  
 AbstractApplicationContext入口 refresh[/size] 
  
[img]http://dl2.iteye.com/upload/attachment/0086/2742/fb2361e5-5c98-350a-aa06-808124297b7a.jpg[/img] 
  
 [size=medium]显然所有的BeanFactoryPostProcessor会在此处被调用，包括注册Scope的CustomScopeConfigurer，因为它是一个BeanFactoryPostProcessor实例。[/size] 
  

	@SuppressWarnings("unchecked")
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		if (this.scopes != null) {
			for (Map.Entry entry : this.scopes.entrySet()) {
				String scopeKey = entry.getKey();
				Object value = entry.getValue();
				if (value instanceof Scope) {
					beanFactory.registerScope(scopeKey, (Scope) value);
				}
				else if (value instanceof Class) {
					Class scopeClass = (Class) value;
					Assert.isAssignable(Scope.class, scopeClass);
					beanFactory.registerScope(scopeKey, (Scope) BeanUtils.instantiateClass(scopeClass));
				}
				else if (value instanceof String) {
					Class scopeClass = ClassUtils.resolveClassName((String) value, this.beanClassLoader);
					Assert.isAssignable(Scope.class, scopeClass);
					beanFactory.registerScope(scopeKey, (Scope) BeanUtils.instantiateClass(scopeClass));
				}
				else {
					throw new IllegalArgumentException("Mapped value [" + value + "] for scope key [" +
							scopeKey + "] is not an instance of required type [" + Scope.class.getName() +
							"] or a corresponding Class or String value indicating a Scope implementation");
				}
			}
		}
	}
 
  
[size=medium]那不得不提的是BeanFactoryPostProcessor的调用情况 
  
 1.可以编程式的添加BeanFactoryPostProcessor和对于BeanFactory是BeanDefinitionRegistry类型的可以声明式的注册BeanFactoryPostProcessor实例 
  
 2.BeanFactoryPostProcessor的子类BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法被调用 
  
 3.调用顺序为: 
  
 编程式添加的BeanFactoryPostProcessor子类实例的postProcessBeanDefinitionRegistry方法 
  
 声明式注册的BeanFactoryPostProcessor子类实例的postProcessBeanDefinitionRegistry方法 
  
 编程式添加的BeanFactoryPostProcessor子类实例的postProcessBeanFactory方法 
  
 声明式注册的BeanFactoryPostProcessor子类实例的postProcessBeanFactory方法 
  
 编程式添加的BeanFactoryPostProcessor实例的postProcessBeanFactory方法 
  
 声明式注册的BeanFactoryPostProcessor实现PriorityOrdered接口实例的postProcessBeanFactory方法 
  
 声明式注册的BeanFactoryPostProcessor实现Ordered接口实例的postProcessBeanFactory方法 
  
 声明式注册的BeanFactoryPostProcessor没有实现PriorityOrdered或Ordered接口实例的postProcessBeanFactory方法[/size] 
  
 
  

/**
	 * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
	 * respecting explicit order if given.
	 * 
Must be called before singleton instantiation.
	 */
	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set processedBeans = new HashSet();
		if (beanFactory instanceof BeanDefinitionRegistry) {
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
			List regularPostProcessors = new LinkedList();
			List registryPostProcessors =
					new LinkedList();
			for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
					registryPostProcessors.add(registryPostProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}
			Map beanMap =
					beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);
			List registryPostProcessorBeans =
					new ArrayList(beanMap.values());
			OrderComparator.sort(registryPostProcessorBeans);
			for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {
				postProcessor.postProcessBeanDefinitionRegistry(registry);
			}
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
			processedBeans.addAll(beanMap.keySet());
		}
		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List priorityOrderedPostProcessors = new ArrayList();
		List orderedPostProcessorNames = new ArrayList();
		List nonOrderedPostProcessorNames = new ArrayList();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		OrderComparator.sort(priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List orderedPostProcessors = new ArrayList();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		OrderComparator.sort(orderedPostProcessors);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List nonOrderedPostProcessors = new ArrayList();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
	}
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring3.x)

        

            

                
    
                    
  • SpringBoot自动装配原理分析(二)
                        让bug再飞一会
springbootjava后端
                        
    在前面的分析中，SpringFramework一直在致力于解决一个问题，就是如何让bean的管理变得更简单，如何让开发者尽可能的少关注一些基础化的bean的配置，从而实现自动装配。所以，所谓的自动装配，实际上就是如何自动将bean装载到Ioc容器中来。实际上在spring3.x版本中，Enable模块驱动注解的出现，已经有了一定的自动装配的雏形，而真正能够实现这一机制，还是在spirng4.x版本
    
                    
    • 
                    
  • 关于idea中新建springboot项目Java版本不能选择11和8的解决办法
                        aniceperson999
intellij-ideajavaide
                        
    原因：spring2.X版本在2023年11月24日停止维护了，因此创建spring项目时不再有2.X版本的选项，只能从3.1.X版本开始选择而Spring3.X版本不支持JDK8，JDK11，最低支持JDK17，因此JDK11也无法选择了当然，停止维护只代表我们无法用idea主动创建spring2.X版本的项目了，不代表我们无法使用，该使用依然能使用，丝毫不受影响目前阿里云还是支持创建Sprin
    
                    
    • 
                    
  • 深入了解Spring缓存注解：@Cacheable、@CacheEvict、@CachePut
                        #难得糊涂
spring缓存java
                        
    引言在现代应用程序中，缓存是提高性能和响应速度的重要手段。Spring框架提供了一组强大的缓存注解，其中包括@Cacheable、@CacheEvict和@CachePut。让我们深入了解这些注解的用途和适用场景。Spring缓存的发展Spring3.x基础支持：在Spring3.x版本中，引入了org.springframework.cache.CacheManager接口来实现缓存管理。它提供
    
                    
    • 
                    
  • springboot2.x到spring3.x的一些变化和示例说明
                        闫小甲
springspringbootspringcloud
                        
    最近在做微服务版本升级工作，整理springboot2.x到spring3.x（spring5.x到spring6.x）的一些变化和示例说明。1.Java版本要求SpringBoot2.5.0：支持Java8及以上版本。SpringBoot3.3.0：要求Java17及以上版本，并且支持Java21。这意味着在升级过程中，首先需要确保JDK版本符合要求，并可能需要进行JDK的升级。2.底层依赖更新
    
                    
    • 
                    
  • 深度剖析Spring Boot自动装配机制实现原理
                        跟着Mic学架构

                        
    SpringBoot自动装配在前面的分析中，SpringFramework一直在致力于解决一个问题，就是如何让bean的管理变得更简单，如何让开发者尽可能的少关注一些基础化的bean的配置，从而实现自动装配。所以，所谓的自动装配，实际上就是如何自动将bean装载到Ioc容器中来。实际上在spring3.x版本中，Enable模块驱动注解的出现，已经有了一定的自动装配的雏形，而真正能够实现这一机制，
    
                    
    • 
                    
  • springBoot集成mybatis+mysql项目搭建
                        FromNowOnUntilTheEnd
SpringBoot
                        
    大家都知道，现在Spring框架几乎无处不用，目前最新版本据说是Spring5，现在常用的基本还是Spring4.X，很多公司甚至用的还是Spring3.x，而Spring领域其中最好用的莫过于SpringBoot，这是从SpringMVC衍变出来的，本质还是SpringMVC，但是要比SpringMVC好用的多，因为很好用，所以笔者闲暇之际用SpringBoot从头至尾摸索着搭建了一个案例，分享
    
                    
    • 
                    
  • Spring3.X学习笔记-SpringAOP增强与切面
                        岸远水声微
springaop增强aop切面springaop
                        
    上一篇文章介绍了SpringAOP的基础知识以及所依赖的底层Java技术，本篇来说下SpringAOP的增强类型以及切面类型。SpringAop的增强类型AOP联盟为增强定义了org.aopaliance.aop.Advice接口，下图为增强接口继承关系图：带《spring》标识的接口是Spring所定义的扩展增强接口；带《aopalliance》标识的接口则是AOP联盟定义的接口。按照增强在目标
    
                    
    • 
                    
  • Spring5学习随笔-高级注解（@ComponentScan、@Configuration.....），替换XML配置文件
                        rookies99
Spring5学习springjava
                        
    学习视频：【孙哥说Spring5：从设计模式到基本应用到应用级底层分析，一次深入浅出的Spring全探索。学不会Spring？只因你未遇见孙哥】第三章、Spring的高级注解(Spring3.x及以上)1.配置BeanSpring在3.x提供的新的注解，用于替换XML配置文件。@ConfigurationpublicclassAppConfig{}问题：配置Bean在应用的过程中替换了XML具体的
    
                    
    • 
                    
  • idea创建spring boot项目，java版本只能选择17和21
                        阿里嘎多f
ideajavajavaintellij-ideaspringboot
                        
    1.问题描述java版本为"11.0.20"，idea2023创建springboot项目时（File->Project->SpringInitializr），java版本无法选择11，导致报错，如下图所示：2.原因spring2.X版本在2023年11月24日停止维护了，因此创建spring项目时不再有2.X版本的选项，只能从3.1.X版本开始选择而Spring3.X版本不支持JDK8，JDK1
    
                    
    • 
                    
  • ThreadLocal详解
                        JacobGo
Spring相关ThreadLocal详解
                        
    本文参考自：《Spring3.x企业应用开发实战》，http://blog.csdn.net/lufeng20/article/details/243143811.ThhreadLocal详解1.1ThreadLocal是什么早在JDK1.2的版本中就提供Java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出
    
                    
    • 
                    
  • SpringBoot 源码分析(二) 自动装配过程分析
                        不知名的艾坤
SSMSpringBoot源码分析springbootjava后端
                        
    一、自动装配原理前置知识自动装配就是自动将bean装载到Ioc容器中。实际上在spring3.x版本中，Enable模块驱动注解的出现，已经有了一定的自动装配的雏形，而真正能够实现这一机制，还是在spirng4.x版本中，conditional条件注解的出现。@EnableAutoConfiguration注解的实现原理该注解其中真正实现自动配置功能的核心实现者AutoConfigurationI
    
                    
    • 
                    
  • Spring 3 x 企业应用开发实战 含CD光盘1张
                        又是一个装逼的

                        
    分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！Spring3.x企业应用开发实战(含CD光盘1张)陈雄华，林开雄著ISBN978-7-121-15213-92012年2月出版定价：90.00元（含光盘1张）16开728页宣传语：10年技术专家邀您共享Spri
    
                    
    • 
                    
  • 【JUC】一文弄懂@Async的使用与原理
                        起名方面没有灵感
JUC开发语言springspringboot
                        
    文章目录1.@Async异步任务概述2.深入@Async的底层2.1@Async注解2.2@EnableAsync注解2.3默认线程池1.@Async异步任务概述在Spring3.X的版本之后，内置了@Async解决了多个任务同步进行导致接口响应迟缓的情况。使用@Async注解可以异步执行一个任务，这个任务的返回值必定为null，所以在使用@Async推荐返回值为NULL。那么该如何使用@Asyn
    
                    
    • 
                    
  • springboot 与异步任务,定时任务,邮件任务
                        吴法刚
#SpringBootspringboot后端java
                        
    异步任务在Java应用中，绝大多数情况下都是通过同步的方式来实现交互处理的；但是在处理与第三方系统交互的时候，容易造成响应迟缓的情况，之前大部分都是使用多线程来完成此类任务，其实，在Spring3.x之后，就已经内置了@Async来完美解决这个问题。SpringBoot实现比较简单主启动类:添加注释:@EnableAsync@EnableScheduling@EnableAsync@MapperS
    
                    
    • 
                    
  • spring3.x升级到sprin5.x问题记录
                        帅帅的小哑巴
#SpringBootspringjavaibatisspring3
                        
    spring3.x升级到sprin5.x问题记录问题一：ibatis报错错误信息：错误原因：解决办法：添加mybatis-2-spring依赖参考文档:[link](https://stackoverflow.com/questions/32353286/no-support-for-ibatis-in-spring4-2-0).问题二：springMappingJacksonJsonView没找
    
                    
    • 
                    
  • Spring boot中异步调用——@Async用法
                        梅西爱骑车

                        
    在Java应用中，绝大多数情况下都是通过同步的方式来实现交互处理的；但是在处理与第三方系统交互的时候，容易造成响应迟缓的情况，之前大部分都是使用多线程来完成此类任务，在spring3.x之后，就已经内置了@Async来解决这个问题。同一个类中，一个方法调用另外一个有@Async的方法，该注解是不会生效的。注解本质使用的是动态代理，因为调用方法的是对象本身而不是代理对象，因为没有经过Spring容器
    
                    
    • 
                    
  • MyBatis最新官方下载地址
                        yongwenhao_ywh

                        
    MyBatis最新官方下载地址为：http://code.google.com/p/mybatis/写这篇博客时最新版本（稳定版非SNAPSHOT版本）如下：mybatis-3.1.1-bundle.zipmybatis-spring-1.1.1-bundle.zipmybatis-spring-xxxx.zip是用于无缝整合Spring3.X和MyBatis3.X的，网上有官方中文教程，可以自行
    
                    
    • 
                    
  • Spring Boot自动装配原理
                        海·是倒过来的天
javaspringbootspring
                        
    SpringBoot自动装配主要是基于注解编程和约定优于配置的思想来进行设计的，这种装配就是由Spring自动的把其他组建中的Bean装载到IOC容器中，不需要开发人员再去配置文件中添加大量的配置文件，我们只需要在SpringBoot的启动类上添加一个@SpringBootApplication的一个注解，这样的话就可以开启自动装配，这种自动装配的思想在Spring3.x以后就开始支持了，我们只要
    
                    
    • 
                    
  • spring2.x与spring3.x区别带来的问题
                        PlayAround
杂项javaspringactiviti5beanexception
                        
    今天集成spring与activiti时发现的问题，那是相当的晕。我先是通过maven集成了spring3.2.x与activiti5.15，然后做了测试流程都正常。这时候我就想把activiti集成进公司的框架中，公司的框架是使用的spring2.5，我和原来一样添加jar包，添加流程引擎的配置，写测试。但是报了一个很奇怪的错误，如下：org.springframework.beans.Type
    
                    
    • 
                    
  • Spring中 @Autowired注解与@Resource注解的区别
                        会飞的蜗牛F

                        
    Spring中@Autowired注解与@Resource注解的区别在Spring3.X中经常使用到@Autowired和@Resource进行装配。相同点：@Resource的作用相当于@Autowired，均可标注在字段或属性的setter方法上。不同点：（1）提供方：@Autowired是由org.springframework.beans.factory.annotation.Autowi
    
                    
    • 
                    
  • Spring 整体架构
                        城市里永远的学习者

                        
    先来看spring3.x和spring4.x的整体架构图：spring3.xspring4.x首先我们看到Spring框架被分成7部分：CoreContainer(核心容器)，DataAccess/Integration、WEB、AOP、Instrumentation、Messaging(消息)和Test(测试)，这篇博客我们把注意点放到最核心的核心容器上来进行总结。核心容器核心容器包括了：Bea
    
                    
    • 
                    
  • 29--Pointcut和Advisor以及静态普通方法名匹配切面
                        闲来也无事

                        
    上一篇我们简单介绍了一下AOP中的一些相关术语、以及Advice接口下的一些增强实现，但是这里会有一个问题，那就是增强方法还会被应用到目标类的所有接口。修改一下上一节的测试类并运行。（本篇很多简介摘自Spring3.X企业应用开发实战，实在想不出来如何去介绍这些概念类的信息。。。）1.Pointcut概念的引入及简介@Testpublicvoidtest5(){//前置增强//1、实例化bean和
    
                    
    • 
                    
  • Spring/Spring Boot中使用@Async
                        我的小熊不见了

                        
    当我们在调用某些耗时的方法，比如发起第三方调用时而不关心他的返回值，可以采用@Async来实现异步调用。极大的提升程序的响应速度。在以往的编程方法中我们一般都是开启另一个线程去处理类似的场景，而在Spring3.x之后则可以使用@Async。@Target({ElementType.METHOD,ElementType.TYPE})@Retention(RetentionPolicy.RUNTIM
    
                    
    • 
                    
  • Spring3.X学习笔记-基于注解和Java类的配置
                        岸远水声微
springspring注解annotation
                        
    上一篇文章里我们主要介绍了基于XMLSchemal的配置方式。本篇文章里将介绍另外两种提供Bean定义的方式，基于注解和基于Java类的配置。1、基于注解的配置不管是XML还是注解，他们都是表达Bean定义的载体，其实质都是为Spring容器提供Bean定义的信息，表现形式上是将XML定义的东西通过类注解进行描述。Spring从2.0开始引入基于注解的配置方式，在3.0时得到进一步的完善。下面是使
    
                    
    • 
                    
  • spring boot + vue + element-ui全栈开发入门——开篇
                        weixin_34342992
javascriptui前端ViewUI
                        
    最近经常看到很多java程序员朋友还在使用Spring3.x，SpringMVC(struts)，JSP、jQuery等这样传统技术。其实，我并不认为这些传统技术不好，而我想表达的是，技术的新旧程度体现了做项目时的生产力。生产力低了，项目的开发成本就高。反之，生产力高，则成本低。笔者写本系列的目的是让使用“前后端不分离”的老技术的开发者做一个入门级的过度。因为目前流行的“前后端分离”技术足够简单，
    
                    
    • 
                    
  • Spring 3.x 企业应用开发实战(含CD光盘1张)
                        博文视点
spring企业应用webservice任务调度java单元测试
                        
    Spring3.x企业应用开发实战(含CD光盘1张)陈雄华，林开雄著ISBN978-7-121-15213-92012年2月出版定价：90.00元（含光盘1张）16开728页宣传语：10年技术专家邀您共享Spring饕餮盛宴内容简介Spring3.0是Spring在积蓄了3年之久后，隆重推出的一个重大升级版本，进一步加强了Spring作为Java领域第一开源平台的翘楚地位。Spring3.0引入了
    
                    
    • 
                    
  • maven项目，去除引入jar包中不需要的依赖库
                        PHPMyCMS

                        
    我用的是jersey-spring1.81.jar版本，该项目依赖的是spring3，所以把jersey-spring1.81.jar加入maven或就出现了这样的情况，由于它依赖spring3.x，所以自动导入了spring3.x的jar，并把我spring4.x的包自动删除了，导致spring4.x根本无法构建，可是我已经有4.x的包，完全不需要它自动导入3的包删除4的包啊！解决版本：去除je
    
                    
    • 
                    
  • 基于SpringBoot开机启动与@Order注解
                        

                        
    目录SpringBoot开机启动与@Order注解spring@Order标记@Order标记定义了组件的加载顺序使用spring3.x和spring4.x的例子SpringBoot开机启动与@Order注解packagecom.example.zcw.runner;importlombok.extern.slf4j.Slf4j;importorg.springframework.boot.App
    
                    
    • 
                    
  • 深度剖析Spring Boot自动装配机制实现原理
                        
java
                        
    在前面的分析中，SpringFramework一直在致力于解决一个问题，就是如何让bean的管理变得更简单，如何让开发者尽可能的少关注一些基础化的bean的配置，从而实现自动装配。所以，所谓的自动装配，实际上就是如何自动将bean装载到Ioc容器中来。实际上在spring3.x版本中，Enable模块驱动注解的出现，已经有了一定的自动装配的雏形，而真正能够实现这一机制，还是在spirng4.x版本
    
                    
    • 
                    
  • 深度剖析Spring Boot自动装配机制实现原理
                        跟着Mic学架构

                        
    在前面的分析中，SpringFramework一直在致力于解决一个问题，就是如何让bean的管理变得更简单，如何让开发者尽可能的少关注一些基础化的bean的配置，从而实现自动装配。所以，所谓的自动装配，实际上就是如何自动将bean装载到Ioc容器中来。实际上在spring3.x版本中，Enable模块驱动注解的出现，已经有了一定的自动装配的雏形，而真正能够实现这一机制，还是在spirng4.x版本
    
                    
    • 
                                
  • 戴尔笔记本win8系统改装win7系统
                                    sophia天雪
win7戴尔改装系统win8
                                    
    戴尔win8 系统改装win7 系统详述  
 
第一步：使用U盘制作虚拟光驱： 
        1）下载安装UltraISO：注册码可以在网上搜索。 
        2）启动UltraISO，点击“文件”—》“打开”按钮，打开已经准备好的ISO镜像文 

    
                                
    • 
                                
  • BeanUtils.copyProperties使用笔记
                                    bylijinnan
java
                                    
    BeanUtils.copyProperties VS PropertyUtils.copyProperties 
 
两者最大的区别是： 
BeanUtils.copyProperties会进行类型转换，而PropertyUtils.copyProperties不会。 
既然进行了类型转换，那BeanUtils.copyProperties的速度比不上PropertyUtils.copyProp
    
                                
    • 
                                
  • MyEclipse中文乱码问题
                                    0624chenhong
MyEclipse
                                    
    一、设置新建常见文件的默认编码格式，也就是文件保存的格式。 
在不对MyEclipse进行设置的时候，默认保存文件的编码，一般跟简体中文操作系统（如windows2000，windowsXP）的编码一致，即GBK。 
在简体中文系统下，ANSI 编码代表 GBK编码;在日文操作系统下，ANSI 编码代表 JIS 编码。 
Window-->Preferences-->General -
    
                                
    • 
                                
  • 发送邮件
                                    不懂事的小屁孩
send email
                                    
      
import org.apache.commons.mail.EmailAttachment;  
import org.apache.commons.mail.EmailException;  
import org.apache.commons.mail.HtmlEmail;  
import org.apache.commons.mail.MultiPartEmail;  

    
                                
    • 
                                
  • 动画合集
                                    换个号韩国红果果
htmlcss
                                    
    动画 指一种样式变为另一种样式 keyframes应当始终定义0 100 过程 
1 transition  制作鼠标滑过图片时的放大效果 
 

css
.wrap{
		width: 340px;height: 340px;
		position: absolute;
		top: 30%;
		left: 20%;
		overflow: hidden;
		bor
    
                                
    • 
                                
  • 网络最常见的攻击方式竟然是SQL注入
                                    蓝儿唯美
sql注入
                                    
    NTT研究表明，尽管SQL注入（SQLi）型攻击记录详尽且为人熟知，但目前网络应用程序仍然是SQLi攻击的重灾区。 
信息安全和风险管理公司NTTCom Security发布的《2015全球智能威胁风险报告》表明，目前黑客攻击网络应用程序方式中最流行的，要数SQLi攻击。报告对去年发生的60亿攻击 行为进行分析，指出SQLi攻击是最常见的网络应用程序攻击方式。全球网络应用程序攻击中，SQLi攻击占
    
                                
    • 
                                
  • java笔记2
                                    a-john
java
                                    
    类的封装： 
1，java中，对象就是一个封装体。封装是把对象的属性和服务结合成一个独立的的单位。并尽可能隐藏对象的内部细节（尤其是私有数据） 
2，目的：使对象以外的部分不能随意存取对象的内部数据（如属性），从而使软件错误能够局部化，减少差错和排错的难度。 
3，简单来说，“隐藏属性、方法或实现细节的过程”称为——封装。 
4，封装的特性： 
      4.1设置
    
                                
    • 
                                
  • [Andengine]Error：can't creat bitmap form path “gfx/xxx.xxx”
                                    aijuans
学习Android遇到的错误
                                    
            最开始遇到这个错误是很早以前了，以前也没注意，只当是一个不理解的bug，因为所有的texture，textureregion都没有问题，但是就是提示错误。 
 
昨天和美工要图片，本来是要背景透明的png格式，可是她却给了我一个jpg的。说明了之后她说没法改，因为没有png这个保存选项。 
 
我就看了一下，和她要了psd的文件，还好我有一点
    
                                
    • 
                                
  • 自己写的一个繁体到简体的转换程序
                                    asialee
java转换繁体filter简体
                                    
              今天调研一个任务，基于java的filter实现繁体到简体的转换，于是写了一个demo，给各位博友奉上，欢迎批评指正。 
         实现的思路是重载request的调取参数的几个方法，然后做下转换。 
          
    
                                
    • 
                                
  • android意图和意图监听器技术
                                    百合不是茶
android显示意图隐式意图意图监听器
                                    
    Intent是在activity之间传递数据;Intent的传递分为显示传递和隐式传递 
  
显式意图：调用Intent.setComponent() 或 Intent.setClassName() 或 Intent.setClass()方法明确指定了组件名的Intent为显式意图，显式意图明确指定了Intent应该传递给哪个组件。 
  
隐式意图;不指明调用的名称,根据设
    
                                
    • 
                                
  • spring3中新增的@value注解
                                    bijian1013
javaspring@Value
                                    
            在spring 3.0中，可以通过使用@value，对一些如xxx.properties文件中的文件，进行键值对的注入，例子如下： 
1.首先在applicationContext.xml中加入：    
<beans xmlns="http://www.springframework.
    
                                
    • 
                                
  • Jboss启用CXF日志
                                    sunjing
logjbossCXF
                                    
    1. 在standalone.xml配置文件中添加system-properties： 
    <system-properties>        <property name="org.apache.cxf.logging.enabled" value=&
    
                                
    • 
                                
  • 【Hadoop三】Centos7_x86_64部署Hadoop集群之编译Hadoop源代码
                                    bit1129
centos
                                    
      编译必需的软件 
 
 Firebugs3.0.0 
 Maven3.2.3 
 Ant 
 JDK1.7.0_67 
 protobuf-2.5.0 
 Hadoop 2.5.2源码包 
 
  
  
  
 
 Firebugs3.0.0 
 
  
http://sourceforge.jp/projects/sfnet_findbug
    
                                
    • 
                                
  • struts2验证框架的使用和扩展
                                    白糖_
框架xmlbeanstruts正则表达式
                                    
    struts2能够对前台提交的表单数据进行输入有效性校验，通常有两种方式： 
1、在Action类中通过validatexx方法验证，这种方式很简单，在此不再赘述； 
2、通过编写xx-validation.xml文件执行表单验证，当用户提交表单请求后，struts会优先执行xml文件，如果校验不通过是不会让请求访问指定action的。 
本文介绍一下struts2通过xml文件进行校验的方法并说
    
                                
    • 
                                
  • 记录-感悟
                                    braveCS
感悟
                                    
    再翻翻以前写的感悟，有时会发现自己很幼稚，也会让自己找回初心。 
  
2015-1-11  1. 能在工作之余学习感兴趣的东西已经很幸福了； 
2. 要改变自己，不能这样一直在原来区域，要突破安全区舒适区，才能提高自己，往好的方面发展； 
3. 多反省多思考；要会用工具，而不是变成工具的奴隶； 
4. 一天内集中一个定长时间段看最新资讯和偏流式博
    
                                
    • 
                                
  • 编程之美-数组中最长递增子序列
                                    bylijinnan
编程之美
                                    
    
import java.util.Arrays;
import java.util.Random;

public class LongestAccendingSubSequence {

	/**
	 * 编程之美 数组中最长递增子序列 
	 * 书上的解法容易理解
	 * 另一方法书上没有提到的是，可以将数组排序（由小到大）得到新的数组，
	 * 然后求排序后的数组与原数
    
                                
    • 
                                
  • 读书笔记5
                                    chengxuyuancsdn
重复提交struts2的token验证
                                    
    1、重复提交 
2、struts2的token验证 
3、用response返回xml时的注意 
 
1、重复提交 
(1)应用场景 
(1-1)点击提交按钮两次。 
(1-2)使用浏览器后退按钮重复之前的操作，导致重复提交表单。 
(1-3)刷新页面 
(1-4)使用浏览器历史记录重复提交表单。 
(1-5)浏览器重复的 HTTP 请求。 
(2)解决方法 
(2-1)禁掉提交按钮 
(2-2)
    
                                
    • 
                                
  • [时空与探索]全球联合进行第二次费城实验的可能性
                                    comsci

                                    
     
 
     二次世界大战前后,由爱因斯坦参加的一次在海军舰艇上进行的物理学实验 -费城实验 
  至今给我们大家留下很多迷团..... 
 
     关于费城实验的详细过程,大家可以在网络上搜索一下,我这里就不详细描述了 
 
     在这里,我的意思是,现在
    
                                
    • 
                                
  • easy connect 之 ORA-12154: TNS: 无法解析指定的连接标识符
                                    daizj
oracleORA-12154
                                    
    用easy connect连接出现“tns无法解析指定的连接标示符”的错误，如下： 
C:\Users\Administrator>sqlplus username/[email protected]:1521/orcl 
SQL*Plus: Release 10.2.0.1.0 – Production on 星期一 5月 21 18:16:20 2012 
Copyright (c) 198
    
                                
    • 
                                
  • 简单排序:归并排序
                                    dieslrae
归并排序
                                    
    
    public void mergeSort(int[] array){
        int temp = array.length/2;
        
        if(temp == 0){
            return;
        }
        
        int[] a = new int[temp];
        int
    
                                
    • 
                                
  • C语言中字符串的\0和空格
                                    dcj3sjt126com
c
                                    
       \0 为字符串结束符，比如说： 
                      abcd (空格)cdefg； 
存入数组时，空格作为一个字符占有一个字节的空间，我们
    
                                
    • 
                                
  • 解决Composer国内速度慢的办法
                                    dcj3sjt126com
Composer
                                    
    用法： 
有两种方式启用本镜像服务： 
1 将以下配置信息添加到 Composer 的配置文件 config.json 中（系统全局配置）。见“例1” 
2 将以下配置信息添加到你的项目的 composer.json 文件中（针对单个项目配置）。见“例2” 
为了避免安装包的时候都要执行两次查询，切记要添加禁用 packagist 的设置，如下      1   2   3   4   5    
    
                                
    • 
                                
  • 高效可伸缩的结果缓存
                                    shuizhaosi888
高效可伸缩的结果缓存
                                    
    /**
 * 要执行的算法，返回结果v
 */
public interface Computable<A, V> {
	public V comput(final A arg);

}
 
  
/**
 * 用于缓存数据
 */
public class Memoizer<A, V> implements Computable<A, 
    
                                
    • 
                                
  • 三点定位的算法
                                    haoningabc
c算法
                                    
    三点定位， 
已知a,b,c三个顶点的x,y坐标 
和三个点都z坐标的距离，la，lb,lc 
 
求z点的坐标 
原理就是围绕a,b,c 三个点画圆，三个圆焦点的部分就是所求 
但是，由于三个点的距离可能不准，不一定会有结果， 
所以是三个圆环的焦点，环的宽度开始为0，没有取到则加1 
运行 
gcc -lm test.c 
test.c代码如下 
 

#include "stdi
    
                                
    • 
                                
  • epoll使用详解
                                    jimmee
clinux服务端编程epoll
                                    
    epoll - I/O event notification facility在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linu
    
                                
    • 
                                
  • Hibernate对Enum的映射的基本使用方法
                                    linzx0212
enumHibernate
                                    
      
枚举 
  
/**
 * 性别枚举
 */
public enum Gender {

    MALE(0), FEMALE(1), OTHER(2);

    private Gender(int i) {
        this.i = i;
    }

    private int i;

    public int getI
    
                                
    • 
                                
  • 第10章 高级事件（下）
                                    onestopweb
事件
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • 孙子兵法
                                    roadrunners
孙子兵法
                                    
    始计第一 
 
孙子曰： 
兵者，国之大事，死生之地，存亡之道，不可不察也。 
故经之以五事，校之以计，而索其情：一曰道，二曰天，三曰地，四曰将，五 
曰法。道者，令民于上同意，可与之死，可与之生，而不危也；天者，阴阳、寒暑 
、时制也；地者，远近、险易、广狭、死生也；将者，智、信、仁、勇、严也；法 
者，曲制、官道、主用也。凡此五者，将莫不闻，知之者胜，不知之者不胜。故校 
之以计，而索其情，曰
    
                                
    • 
                                
  • MySQL双向复制
                                    tomcat_oracle
mysql
                                    
    本文包括: 
 
  主机配置  
  从机配置  
  建立主-从复制  
  建立双向复制  
 
  背景 
按照以下简单的步骤: 
参考一下： 
 
  在机器A配置主机(192.168.1.30)  
  在机器B配置从机(192.168.1.29)  
  我们可以使用下面的步骤来实现这一点  
 
  
步骤1：机器A设置主机 
 
  在主机中打开配置文件 , 
    
                                
    • 
                                
  • zoj 3822 Domination(dp)
                                    阿尔萨斯
Mina
                                    
     题目链接：zoj 3822 Domination 
 题目大意：给定一个N∗M的棋盘，每次任选一个位置放置一枚棋子，直到每行每列上都至少有一枚棋子，问放置棋子个数的期望。 
 解题思路：大白书上概率那一张有一道类似的题目，但是因为时间比较久了，还是稍微想了一下。dp[i][j][k]表示i行j列上均有至少一枚棋子，并且消耗k步的概率（k≤i∗j）,因为放置在i+1~n上等价与放在i+1行上，同理
    
                                
    •