迷途小码农
迷途小码农

OpenFeign源码

OpenFeign其实还是负责通信的，在使用过程中，让开发者可以面向接口开发的方式进行远程调用，那么：

  1. OpenFeign的注解是如何被扫描解析的呢？
  2. 注解标注的接口注入到IoC中的实例是什么？
  3. OpenFeign的上下文是如何构建的呢？
  4. 远程通信是如何实现的呢？与RestTemplate有关系么？

带着以上的问题，准备开始Feign的源码，同样的 在Spring的生态下，切入点还是那几个，EnableFeignClients和FeignAutoConfiguration，其实 如果看一眼spring-cloud-openfeign-core里面的spring.factories就发现 这里面其实有好多AutoConfiguration。

OpenFeign初始化

@EnableFeignClients

这个注解

/**
 * Scans for interfaces that declare they are feign clients (via
 * {@link org.springframework.cloud.openfeign.FeignClient} @FeignClient).
 * Configures component scanning directives for use with
 * {@link org.springframework.context.annotation.Configuration}
 * @Configuration classes.
 * 扫描所有标注了@FeignClient的接口 将其配置成配置类
 */
@Import(FeignClientsRegistrar.class)
public @interface EnableFeignClients {
    ....
}

这时候 关注点就应该在FeignClientsRegistrar

FeignClientsRegistrar

虽然没有在任何的配置中看到 实例化它，但是它实例化的还是很早的，在 org.springframework.context.annotation.ConfigurationClassParser#processImports

registerBeanDefinitions

class FeignClientsRegistrar
        implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

    ....
    // 重点关注这里 ImportBeanDefinitionRegistrar#registerBeanDefinitions
    // 两个参数分别是StandardAnnotationMetadata, DefaultListableBeanFactory
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
                                        BeanDefinitionRegistry registry) {
        
        // 如果注解中的defaultConfiguration不为空 则将其注入到IoC容器
        registerDefaultConfiguration(metadata, registry);
        // 这里是注入FeignClient的地方
        registerFeignClients(metadata, registry);
    }
    ....
}

registerFeignClients

class FeignClientsRegistrar
        implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {

    ....
    public void registerFeignClients(AnnotationMetadata metadata,
                                     BeanDefinitionRegistry registry) {

        LinkedHashSet candidateComponents = new LinkedHashSet<>();
        // 获取 @EnableFeignClients 所有的配置信息
        Map attrs = metadata
                .getAnnotationAttributes(EnableFeignClients.class.getName());
        AnnotationTypeFilter annotationTypeFilter = new AnnotationTypeFilter(FeignClient.class);
        // 获取 @EnableFeignClients.clients 的值
        final Class[] clients = attrs == null ? null
                : (Class[]) attrs.get("clients");
        if (clients == null || clients.length == 0) {
            ClassPathScanningCandidateComponentProvider scanner = getScanner();
            scanner.setResourceLoader(this.resourceLoader);
            scanner.addIncludeFilter(new AnnotationTypeFilter(FeignClient.class));
            // 这个集合必然不为空 分别取了value、basePackages、basePackageClasses
            // 如果那三个为空 则将标注了@EnableFeignClients 的类所在的路径加入到这个集合
            Set basePackages = getBasePackages(metadata);
            for (String basePackage : basePackages) {
                candidateComponents.addAll(scanner.findCandidateComponents(basePackage));
            }
        } else {
            for (Class clazz : clients) {
                candidateComponents.add(new AnnotatedGenericBeanDefinition(clazz));
            }
        }
        
        // 遍历 并生成代理类 并注入到IoC容器
        for (BeanDefinition candidateComponent : candidateComponents) {
            if (candidateComponent instanceof AnnotatedBeanDefinition) {
                // verify annotated class is an interface
                AnnotatedBeanDefinition beanDefinition = (AnnotatedBeanDefinition) candidateComponent;
                AnnotationMetadata annotationMetadata = beanDefinition.getMetadata();
                Assert.isTrue(annotationMetadata.isInterface(),
                        "@FeignClient can only be specified on an interface");

                Map attributes = annotationMetadata
                        .getAnnotationAttributes(FeignClient.class.getCanonicalName());
                // @FeignClient的value值
                String name = getClientName(attributes);
                registerClientConfiguration(registry, name, attributes.get("configuration"));
                // 注入标注了@FeignClient的接口
                registerFeignClient(registry, annotationMetadata, attributes);
            }
        }
    }
    ....
    
}

registerFeignClient

这里面没啥可说的 就是将被FeignClient标注的接口注入到IoC容器 注入的是 FeignClientFactoryBean

目前这个阶段是初始化，实例化的时候会调用FeignClientFactoryBean.getObject()

class FeignClientsRegistrar
        implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
        
    ....
    private void registerFeignClient(BeanDefinitionRegistry registry,
            AnnotationMetadata annotationMetadata, Map attributes) {
        String className = annotationMetadata.getClassName();
        BeanDefinitionBuilder definition = BeanDefinitionBuilder
                .genericBeanDefinition(FeignClientFactoryBean.class);
        // 校验了 fallback和fallbackFactory
        validate(attributes);
        definition.addPropertyValue("url", getUrl(attributes));
        definition.addPropertyValue("path", getPath(attributes));
        String name = getName(attributes);
        definition.addPropertyValue("name", name);
        // FeignClient并无contextId的配置 这里取的还是name
        String contextId = getContextId(attributes);
        definition.addPropertyValue("contextId", contextId);
        definition.addPropertyValue("type", className);
        definition.addPropertyValue("decode404", attributes.get("decode404"));
        definition.addPropertyValue("fallback", attributes.get("fallback"));
        definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
        definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

        String alias = contextId + "FeignClient";
        AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();
        beanDefinition.setAttribute(FactoryBean.OBJECT_TYPE_ATTRIBUTE, className);

        // has a default, won't be null. default is true
        boolean primary = (Boolean) attributes.get("primary");

        beanDefinition.setPrimary(primary);

        String qualifier = getQualifier(attributes);
        if (StringUtils.hasText(qualifier)) {
            alias = qualifier;
        }

        BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className,
                new String[] { alias });
        BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);
    }
    ....
}

FeignClientFactoryBean#getTarget

首先要清楚FeignClientFactoryBean的实例里面在上面的步骤已经将它里面的值做了初始化。

而在doGetBean时 会调用getObject方法 ，这里如果不清楚，可以看案例关于FactoryBean

其次就是理解getTarget做了哪些事情：

  1. 生成远程代理
  2. 解析接口模板，例如@GetMapping等
  3. 处理负载均衡 集成Ribbon
  4. 包装熔断 继承Hystrix
 T getTarget() {
    // 这个就是feign的上下文 与spring 容器的上下文隔离开了
    FeignContext context = applicationContext.getBean(FeignContext.class);
    // 构建一个Feign的Builder
    Feign.Builder builder = feign(context);

    // 这里判断的是 @FeignClient 的url是否做了配置
    if (!StringUtils.hasText(url)) {
        if (!name.startsWith("http")) {
            url = "http://" + name;
        }
        else {
            url = name;
        }
        url += cleanPath();
        // 这里做负载均衡
        return (T) loadBalance(builder, context,
                               new HardCodedTarget<>(type, name, url));
    }
    if (StringUtils.hasText(url) && !url.startsWith("http")) {
        url = "http://" + url;
    }
    String url = this.url + cleanPath();
    Client client = getOptional(context, Client.class);
    if (client != null) {
        if (client instanceof LoadBalancerFeignClient) {
            // not load balancing because we have a url,
            // but ribbon is on the classpath, so unwrap
            client = ((LoadBalancerFeignClient) client).getDelegate();
        }
        if (client instanceof FeignBlockingLoadBalancerClient) {
            // not load balancing because we have a url,
            // but Spring Cloud LoadBalancer is on the classpath, so unwrap
            client = ((FeignBlockingLoadBalancerClient) client).getDelegate();
        }
        builder.client(client);
    }
    Targeter targeter = get(context, Targeter.class);
    return (T) targeter.target(this, builder, context,
                               new HardCodedTarget<>(type, name, url));
}

FeignClientFactoryBean#feign

只是构建了Feign.Builder，其实就是将一些参数记录。

protected Feign.Builder feign(FeignContext context) {
    
    // get方法 = context.getInstance(contextId, type)
    // 其中 context就是第一个参数 type是第二个参数 
    // contextId是FeignClientsRegistrar.registerFeignClient方法里面设置的
    FeignLoggerFactory loggerFactory = get(context, FeignLoggerFactory.class);
    // 记录日志的 this.logger != null ? this.logger : new Slf4jLogger(type)
    Logger logger = loggerFactory.create(type);

    // @formatter:off
    Feign.Builder builder = get(context, Feign.Builder.class)
        // required values
        .logger(logger)
        .encoder(get(context, Encoder.class))
        .decoder(get(context, Decoder.class))
        .contract(get(context, Contract.class));
    // @formatter:on

    // 配置相关的内容 logger encoder decoder...
    configureFeign(context, builder);

    return builder;
}

FeignClientFactoryBean#loadBalance

名字虽然叫loadBalance，但是这里并没有做负载均衡，第一行代码 Client client = getOptional(context, Client.class);，是从IoC容器中获取Client的Bean，这时触发了IoC容器对该Bean的实例化，代码如下：

@Configuration(proxyBeanMethods = false)
class DefaultFeignLoadBalancedConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public Client feignClient(CachingSpringLoadBalancerFactory cachingFactory,
                              SpringClientFactory clientFactory) {
        return new LoadBalancerFeignClient(new Client.Default(null, null), cachingFactory,
                clientFactory);
    }
}

protected  T loadBalance(Feign.Builder builder, FeignContext context,
                            HardCodedTarget target) {
    // client = org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient
    Client client = getOptional(context, Client.class);
    if (client != null) {
        // 这里构造的client
        builder.client(client);
        // targeter = org.springframework.cloud.openfeign.HystrixTargeter
        // 即使在项目中没有引入hystrix 也是这个类
        Targeter targeter = get(context, Targeter.class);
        // 这里面做动态代理的构建 与 模板方法的解析
        return targeter.target(this, builder, context, target);
    }

    throw new IllegalStateException(
        "No Feign Client for loadBalancing defined. Did you forget to include spring-cloud-starter-netflix-ribbon?");
}

HystrixTargeter#target

public  T target(FeignClientFactoryBean factory, Feign.Builder feign,
                    FeignContext context, Target.HardCodedTarget target) {
    // 没有引入hystrix 时 feign = Feign$Builder 所以就走到了这里
    if (!(feign instanceof feign.hystrix.HystrixFeign.Builder)) {
        // 这里等于 build().newInstance(target),build构建了`ReflectiveFeign`
        // 然后这个newInstance是feign.ReflectiveFeign#newInstance
        return feign.target(target);
    }
    feign.hystrix.HystrixFeign.Builder builder = (feign.hystrix.HystrixFeign.Builder) feign;
    String name = StringUtils.isEmpty(factory.getContextId()) ? factory.getName()
        : factory.getContextId();
    SetterFactory setterFactory = getOptional(name, context, SetterFactory.class);
    if (setterFactory != null) {
        builder.setterFactory(setterFactory);
    }
    Class fallback = factory.getFallback();
    if (fallback != void.class) {
        return targetWithFallback(name, context, target, builder, fallback);
    }
    Class fallbackFactory = factory.getFallbackFactory();
    if (fallbackFactory != void.class) {
        return targetWithFallbackFactory(name, context, target, builder,
                                         fallbackFactory);
    }

    return feign.target(target);
}

这里的代码跳转是这样的，return feign.target(target); 点进去是feign.Feign.Builder#target(feign.Target)，而方法的内容只有return build().newInstance(target);，而build方法 除了实例化了几个类，同时将Builder的一些参数做了传递，

这里做了一件事就是把client传过去了。

最后返回了ReflectiveFeign，所以直接看feign.ReflectiveFeign#newInstance吧

ReflectiveFeign#newInstance

这里就是通过JDK的动态代理 代理所有的接口了

public  T newInstance(Target target) {

    // value 是 feign.SynchronousMethodHandler 这一步是模板解析
    // 这一步初始化了 SynchronousMethodHandler里面的client
    Map nameToHandler = targetToHandlersByName.apply(target);
    Map methodToHandler = new LinkedHashMap();
    List defaultMethodHandlers = new LinkedList();

    for (Method method : target.type().getMethods()) {
        if (method.getDeclaringClass() == Object.class) {
            continue;
        } else if (Util.isDefault(method)) {
            DefaultMethodHandler handler = new DefaultMethodHandler(method);
            defaultMethodHandlers.add(handler);
            methodToHandler.put(method, handler);
        } else {
            methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
        }
    }
    // create方法等于new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
    InvocationHandler handler = factory.create(target, methodToHandler);
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(), new Class[]{target.type()}, handler);

    for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
        defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
}

OpenFeign远程调用

从初始化的流程来看 feign.MethodHandler是feign.SynchronousMethodHandler，而java.lang.reflect.InvocationHandler是feign.ReflectiveFeign.FeignInvocationHandler，然后在调用方法时 首先要进入的就是feign.ReflectiveFeign.FeignInvocationHandler#invoke

ReflectiveFeign.FeignInvocationHandler#invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // 这里时过滤掉Object相关的方法
    if ("equals".equals(method.getName())) {
        try {
            Object otherHandler =
                args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
            return equals(otherHandler);
        } catch (IllegalArgumentException e) {
            return false;
        }
    } else if ("hashCode".equals(method.getName())) {
        return hashCode();
    } else if ("toString".equals(method.getName())) {
        return toString();
    }
    // dispatch是Map (value是SynchronousMethodHandler)
    return dispatch.get(method).invoke(args);
}

SynchronousMethodHandler#executeAndDecode

调用链为：

feign.SynchronousMethodHandler#invoke到feign.SynchronousMethodHandler#executeAndDecode。

Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {
    Request request = targetRequest(template);

    if (logLevel != Logger.Level.NONE) {
        logger.logRequest(metadata.configKey(), logLevel, request);
    }

    Response response;
    long start = System.nanoTime();
    try {
        // 重点在这里 client=org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient
        // 在不做特殊配置的情况下，LoadBalancerFeignClient.delegate=feign.Client$Default
        // 用的还是HttpURLConnection。
        response = client.execute(request, options);
        // ensure the request is set. TODO: remove in Feign 12
        response = response.toBuilder()
            .request(request)
            .requestTemplate(template)
            .build();
    } catch (IOException e) {
        if (logLevel != Logger.Level.NONE) {
            logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
        }
        throw errorExecuting(request, e);
    }
    long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);


    if (decoder != null)
        return decoder.decode(response, metadata.returnType());

    CompletableFuture resultFuture = new CompletableFuture<>();
    asyncResponseHandler.handleResponse(resultFuture, metadata.configKey(), response,
                                        metadata.returnType(),
                                        elapsedTime);

    try {
        if (!resultFuture.isDone())
            throw new IllegalStateException("Response handling not done");

        return resultFuture.join();
    } catch (CompletionException e) {
        Throwable cause = e.getCause();
        if (cause != null)
            throw cause;
        throw e;
    }
}


LoadBalancerFeignClient#execute




到这里能看到一些负载均衡的字眼了 但是追进去会看到好多RxJava的代码，这种反应式代码 只能靠猜。




@Override
public Response execute(Request request, Request.Options options) throws IOException {
    try {
        URI asUri = URI.create(request.url());
        String clientName = asUri.getHost();
        URI uriWithoutHost = cleanUrl(request.url(), clientName);
        FeignLoadBalancer.RibbonRequest ribbonRequest = new FeignLoadBalancer.RibbonRequest(
            this.delegate, request, uriWithoutHost);

        IClientConfig requestConfig = getClientConfig(options, clientName);
        // FeignLoadBalancer.executeWithLoadBalancer 其实是父类AbstractLoadBalancerAwareClient
        return lbClient(clientName)
            .executeWithLoadBalancer(ribbonRequest, requestConfig).toResponse();
    }
    catch (ClientException e) {
        IOException io = findIOException(e);
        if (io != null) {
            throw io;
        }
        throw new RuntimeException(e);
    }
}



public T executeWithLoadBalancer(final S request, final IClientConfig requestConfig) throws ClientException {
    LoadBalancerCommand command = buildLoadBalancerCommand(request, requestConfig);

    try {
        return command.submit(new ServerOperation() {
            @Override
            public Observable call(Server server) {
                URI finalUri = reconstructURIWithServer(server, request.getUri());
                S requestForServer = (S) request.replaceUri(finalUri);
                try {
                    // 最后回调到这里
                    // org.springframework.cloud.openfeign.ribbon.FeignLoadBalancer#execute
                    return Observable.just(AbstractLoadBalancerAwareClient.this.execute(requestForServer, requestConfig));
                } 
                catch (Exception e) {
                    return Observable.error(e);
                }
            }
        }).toBlocking()
        .single(); // 执行之后可以走到com.netflix.loadbalancer.BaseLoadBalancer#chooseServer
    } catch (Exception e) {
        Throwable t = e.getCause();
        if (t instanceof ClientException) {
            throw (ClientException) t;
        } else {
            throw new ClientException(e);
        }
    }

}



总结




这里针对开篇提出的问题做一个总结


    

  1. OpenFeign的注解是如何被扫描解析的呢？
    2. 

  2. 注解标注的接口注入到IoC中的实例是什么？
    3. 

  3. OpenFeign的上下文是如何构建的呢？
    4. 

  4. 远程通信是如何实现的呢？与RestTemplate有关系么？
    5. 





OpenFeign的注解是如何被扫描解析的呢？


通过实现接口ImportBeanDefinitionRegistrar然后注入实例到IoC容器的。


注解标注的接口注入到IoC中的实例是什么？


就是一个JDK的动态代理java.lang.reflect.Proxy，其中java.lang.reflect.Proxy#h的值是ReflectiveFeign$FeignInvocationHandler，如下图所示：


OpenFeign的上下文是如何构建的呢？


public class FeignContext extends NamedContextFactory


远程通信是如何实现的呢？与RestTemplate有关系么？


其实就是这个类org.springframework.cloud.openfeign.ribbon.LoadBalancerFeignClient，这里用到了委派模式，delegate再默认情况下是feign.Client$Default，里面的通信方式是java.net.HttpURLConnection，可以切换到HttpClient或者OkHttp3


RestTemplate默认也是基于java.net.HttpURLConnection封装的一个工具类，Feign中没有直接使用RestTemplate，他们应该属于平级关系，不存在谁使用了谁。


疑问点


如何整合的Ribbon？


LoadBalancerFeignClient


和单独看Ribbon的源码还有联系么？


有关系 但是不太一样了，首先说明一点，Feign 一定要引入spring-cloud-starter-netflix-ribbon，否则在org.springframework.cloud.openfeign.FeignClientFactoryBean#loadBalance就会报错。因此，其实分析的Ribbon的源码过程依旧会走一遍，且Feign比Ribbon 早配置。


为啥说不太一样了呢？因为用了Feign就不需要@LoadBalance和RestTemplate了，所以请求的时候不会再被LoadBalancerInterceptor拦截。后面负载均衡那里还会走到Ribbon的com.netflix.loadbalancer.BaseLoadBalancer#chooseServer。


如何切换请求方式


org.springframework.cloud.openfeign.ribbon.OkHttpFeignLoadBalancedConfiguration


org.springframework.cloud.openfeign.ribbon.HttpClientFeignLoadBalancedConfiguration


org.springframework.cloud.openfeign.loadbalancer.DefaultFeignLoadBalancerConfiguration


Spring的知识点


ImportBeanDefinitionRegistrar


public class TestImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, 
                                        BeanDefinitionRegistry registry) {

        BeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClassName(Hello.class.getName());

        registry.registerBeanDefinition("hello", beanDefinition);
    }

}

class Hello {
    // 省略 getter/setter/toString()
    private String name;
}



// 非Spring Boot的环境下，此注解必须有  不然IoC容器中无Hello
@Import(TestImportBeanDefinitionRegistrar.class)
public class Bootstrap {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Bootstrap.class);
        System.out.println(context.getBean(Hello.class));
    }
}



关于FactoryBean




本案例参考FeignClientFactoryBean，将一个接口做出一个代理对象 同时注入到Spring IoC容器中去。




public class TestFactoryBean implements FactoryBean {

    @Override
    public IHello getObject() {

        return (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), new Class[]{IHello.class}, new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method.getName());
                return "hello FactoryBean";
            }
        });
    }

    @Override
    public Class getObjectType() {

        return IHello.class;
    }

}

interface IHello {

    String sayS();

    Integer sayI();
}



public class TestImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {

        TestFactoryBean factoryBean = new TestFactoryBean();

        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder
                .genericBeanDefinition(IHello.class, () -> factoryBean.getObject()).getBeanDefinition();

        registry.registerBeanDefinition("hello", beanDefinition);
    }

}



@Import(TestImportBeanDefinitionRegistrar.class)
public class Bootstrap {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Bootstrap.class);

        IHello bean = context.getBean(IHello.class);
        System.out.println(bean);
        System.out.println(bean.sayS());
        // 这里会报错 因为方法的返回值是int 但是Proxy里面粗暴返回的String
        System.out.println(bean.sayI());
    }
}

























你可能感兴趣的:(OpenFeign源码)






    

  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
说私域
人工智能小程序

    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    

    • 

  • 四章-32-点要素的聚合
彩云飘过

    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
    

    • 

  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业

    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    

    • 

  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
二挡起步
web前端期末大作业javascripthtmlcss旅游风景

    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    

    • 

  • libyuv之linux编译
jaronho
Linuxlinux运维服务器

    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    

    • 

  • ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea

    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    

    • 

  • Python神器！WEB自动化测试集成工具 DrissionPage
亚丁号
python开发语言

    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
    

    • 

  • 笋丁网页自动回复机器人V3.0.0免授权版源码
希希分享
软希网58soho_cn源码资源笋丁网页自动回复机器人

    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
    

    • 

  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能
小康师兄
ESP32-C3入门教程https服务器esp32OTAMQTT

    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
    

    • 

  • 【Python搞定车载自动化测试】——Python实现车载以太网DoIP刷写（含Python源码）
疯狂的机器人
Python搞定车载自动化pythonDoIPUDSISO142291SO13400Bootloadertcp/ip

    系列文章目录【Python搞定车载自动化测试】系列文章目录汇总文章目录系列文章目录前言一、环境搭建1.软件环境2.硬件环境二、目录结构三、源码展示1.DoIP诊断基础函数方法2.DoIP诊断业务函数方法3.27服务安全解锁4.DoIP自动化刷写四、测试日志1.测试日志五、完整源码链接前言随着智能电动汽车行业的发展，汽车=智能终端+四个轮子，各家车企都推出了各自的OTA升级方案，本章节主要介绍如何使
    

    • 

  • 进销存小程序源码 PHP网络版ERP进销存管理系统 全开源可二开
摸鱼小号
php

    可直接源码搭建部署发布后使用：一、功能模块介绍该系统模板主要有进，销，存三个主要模板功能组成，下面将介绍各模块所对应的功能；进：需要将产品采购入库，自动生成采购明细台账同时关联财务生成付款账单；销：是指对客户的销售订单记录，汇总生成产品销售明细及回款计划；存：库存的日常盘点与统计，库存下限预警、出入库台账、库存位置等。1.进购管理采购订单：采购下单审批→由上级审批通过采购入库；采购入库：货品到货>
    

    • 

  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署）
java毕设程序源码王哥
php课程设计vue.js

    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
    

    • 

  • JVM源码分析之堆外内存完全解读
HeapDump性能社区

    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    

    • 

  • html+css网页设计 旅游网站首页1个页面
html+css+js网页设计
htmlcss旅游

    html+css网页设计旅游网站首页1个页面网页作品代码简单，可使用任意HTML辑软件（如：Dreamweaver、HBuilder、Vscode、Sublime、Webstorm、Text、Notepad++等任意html编辑软件进行运行及修改编辑等操作）。获取源码1，访问该网站https://download.csdn.net/download/qq_42431718/897527112，点击
    

    • 

  • Istio pilot-discovery服务发现源码解析（1.13版本）
xidianjiapei001
#Istioistio云原生服务发现

    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    

    • 

  • python中文版软件下载-Python中文版
编程大乐趣

    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
    

    • 

  • Scanpy源码浅析之pp.normalize_total
何物昂

    版本导入Scanpy,其版本为'1.9.1'，如果你看到的源码和下文有差异，其可能是由于版本差异。importscanpyasscsc.__version__#'1.9.1'例子函数pp.normalize_total用于Normalizecountspercell，其源代码在scanpy/preprocessing/_normalization.py我们通过一个简单例子来了解该函数主要功能:将一
    

    • 

  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
网顺技术团队
成品程序项目javavue.js汽车课程设计springboot

    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    

    • 

  • 【K8s】专题十一：Kubernetes 集群证书过期处理方法
行者Sun1989
Kuberneteskubernetes云原生容器

    本文内容均来自个人笔记并重新梳理，如有错误欢迎指正！如果对您有帮助，烦请点赞、关注、转发、订阅专栏！专栏订阅入口Linux专栏|Docker专栏|Kubernetes专栏往期精彩文章【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法（续）【Docker】MySQL源码构建Docker镜
    

    • 

  • SAP自动化-ME12批量更新最后一行的价格
小九不懂SAP
自动化SAPpython

    Python源码#-Begin-----------------------------------------------------------------#-Includes--------------------------------------------------------------importsys,win32com.clientimportosimporttime#-Sub
    

    • 

  • linux gcc 格式,Linux下gcc与gdb简介
神奇的战士
linuxgcc格式

    gcc编译器可以将C、C++等语言源程序、汇编程序编译、链接成可执行程序。gdb是GNU开发的一个Unix/Linux下强大的程序调试工具。linux下没有后缀名的概念。但gcc根据文件的后缀来区别输入文件的类别：.cC语言源代码文件.a由目标文件构成的库文件.C、.cc、.cppC++源码文件.h头文件.i经过预处理之后的C语言文件.ii经过预处理之后的C++文件.o编译后的目标文件.s汇编源码
    

    • 

  • 浅谈openresty
爱编码的钓鱼佬
nginxopenresty运维

    熟悉了nginx后再来看openresty，不得不说openresty是比较优秀的。对nginx和openresty的历史等在这此就不介绍了。首先对标nginx，自然有优劣一、开发难度nginx：毫无疑问nginx的开发难度比较高，需要扎实的c/c++基础，而且还需要对nginx源码比较熟悉，开发效率慢，比如实现一个类似echo的功能，至少要上百行代码。而openresty只需要一句ngx.say
    

    • 

  • Golang Channel
PandaSkr
golang

    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    

    • 

  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设

    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
    

    • 

  • 使用FPGA接收MIPI CSI RX信号并进行去抖动、RGB转YUV处理：FX3014 USB3.0 UVC传输与帧率控制源代码，FPGA实现MIPI CSI RX接收，去Debayer， RGB转
kVfINoSzdrt
fpga开发程序人生

    fpgamipicsirx接收去debayer,rgb转yuv,fx3014usb3.0uvc传输与帧率控制源代码，具体架构看图，除dphy物理层外，mipi均为源码sensorimx219mipi源码mipi4lanecsirxraw10fpgamachXO3lf-690usb3.0fx301432bityuvdatawithframesync测试模式3280*246415fps1920*108
    

    • 

  • 移动订货小程序哪个好 批发订货系统源码哪个好
多用户商城系统
订货系统源码移动订货小程序批发订货系统订货系统源码

    订货小程序就是依托微信小程序的订货系统，微信小程序订货系统相较于其他终端的订货方式，能够更快进入商城，对经销商而言更为方便。今天，我们一起盘点三个主流的移动订货小程序，看看哪个移动订货小程序好。第一、核货宝订货小程序核货宝是商淘科技旗下的订货系统，可为批发企业提供不同客户不同商品、不同客户不同价格快速订货和商家账期管理。功能介绍：客户批发订货的专属数字化订货系统，可以移动端订货。与传统手写开单相比
    

    • 

  • MacOS Catalina 从源码构建Qt6.2开发库之01: 编译Qt6.2源代码
捕鲸叉
QTmacosc++QT

    安装xcode，cmake，ninjabrewinstallnodemac下安装OpenGL库并使之对各项目可见在macOS上安装OpenGL通常涉及到安装一些依赖库，如MGL、GLUT或者是GLEW等，同时确保LLVM的OpenGL框架和相关工具链的兼容性。以下是一个基本的安装步骤，你可以在终端中执行：安装Homebrew（如果还没有安装的话）：/bin/bash-c"$(curl-fsSLht
    

    • 

  • 基于Python执行lua脚本
xu-jssy
Python自动化脚本pythonlua自动化rpa

    一、依赖安装pipinstalllupa二、源码将lua文件存放在base_path路径，将lua文件名称（不包含后缀名）传递给lua_runner函数即可importmultiprocessingimportlupa#lua文件存放位置base_path='D:\\test\\lua'classLuaFuncion:#创建Lua运行时环境lua=lupa.LuaRuntime(unpack_re
    

    • 

  • Python实现mysql命令行
xu-jssy
pythonmysqladb

    一、源码importosimportpymysqldefsql_shell():password=input("EnterPassword:")#访问密码ifpassword.strip()!="yyds":print("Bye")return#清空控制台输出os.system("cls"ifos.name=="nt"else"clear")try:#连接到MySQL数据库conn=pymysql
    

    • 

  • Java集合类框架源码分析 之 RoleList源码解析 【6】
yunzhonghefei
Java集合类源码分析RoleList源码解析

    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    

    • 

  • java数字签名三种方式
知了ing
javajdk

    以下3钟数字签名都是基于jdk7的
1，RSA
String password="test";
// 1.初始化密钥
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(51
    

    • 

  • Hibernate学习笔记
caoyong
Hibernate

    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King
2>、搭建Hibernate的开发环境
     a>、添加jar包:
     aa>、hibernatte开发包中/lib/required/所
    

    • 

  • 设计模式之装饰器模式Decorator（结构型）
漂泊一剑客
Decorator

    1. 概述
       若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。
      
    

    • 

  • 读取磁盘文件txt，并输入String
一炮送你回车库
String

    public static void main(String[] args) throws IOException {
 
 String fileContent = readFileContent("d:/aaa.txt");
 
 System.out.println(fileContent);
  

    

    • 

  • js三级联动下拉框
3213213333332132
三级联动

    
//三级联动
省/直辖市<select id="province"></select>
市/省直辖<select id="city"></select>
县/区 <select id="area"></select>

    

    • 

  • erlang之parse_transform编译选项的应用
616050468
parse_transform游戏服务器属性同步abstract_code

             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
    

    • 

  • JAVA JSON的解析
darkranger
java

    
// {
// “Total”：“条数”，
// Code: 1,
//
// “PaymentItems”:[
// {
// “PaymentItemID”:”支款单ID”,
// “PaymentCode”:”支款单编号”,
// “PaymentTime”:”支款日期”,
// ”ContractNo”:”合同号”，
// 
    

    • 

  • POJ-1273-Drainage Ditches
aijuans
ACM_POJ

    POJ-1273-Drainage Ditches
http://poj.org/problem?id=1273
基本的最大流，按LRJ的白书写的
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define INF 0x7fffffff
int ma
    

    • 

  • 工作流Activiti5表的命名及含义
atongyeye
工作流Activiti

    activiti5 - http://activiti.org/designer/update在线插件安装
activiti5一共23张表
Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。
ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。
A
    

    • 

  • android的广播机制和广播的简单使用
百合不是茶
android广播机制广播的注册

          Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
    

    • 

  • Spring事务传播行为详解
bijian1013
javaspring事务传播行为

            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。
        Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
    

    • 

  • eidtplus operate
征客丶
eidtplus

    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动
列模式替换或复制内容(多行):
右键-->格式-->填充所选内容-->选择相应操作
OR
Ctrl+Shift+V(复制多行数据,必须行数一致)
-------------------------------------------------------
    

    • 

  • 【Kafka一】Kafka入门
bit1129
kafka

    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧
  下载Kafka
http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz
2.10表示Scala的版本，而0.8.1.1表示Kafka
    

    • 

  • Spring 事务实现机制
BlueSkator
spring代理事务

    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口 
    

    • 

  • bootstrap源码学习与示例：bootstrap-dropdown（转帖）
BreakingBad
bootstrapdropdown

    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。
一个下拉开菜单的设计：
<ul class="nav pull-right">
<li id="fat-menu" class="dropdown">

    

    • 

  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
/*
* 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。
* 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
*
* 在我看来，Mediator模式是把多个对象（
    

    • 

  • 常用代码记录
chenjunt3
UIExcelJ#

     
1、单据设置某行或某字段不能修改
//i是行号,"cash"是字段名称
getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false);
//取得单据表体所有项用以上语句做循环就能设置整行了
getBillC
    

    • 

  • 搜索引擎与工作流引擎
comsci
算法工作搜索引擎网络应用

     
    最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)
  -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
    

    • 

  • oracle Health Monitor
daizj
oracleHealth Monitor

    About Health Monitor
Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database.
About Health Monitor Checks
Health M
    

    • 

  • JSON字符串转换为对象
dieslrae
javajson

        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.
  
    

    • 

  • C语言学习八结构体，综合应用，学生管理系统
dcj3sjt126com
C语言

    实现功能的代码：
# include <stdio.h>
# include <malloc.h>
struct Student
{
int age;
float score;
char name[100];
};
int main(void)
{
int len;
struct Student * pArr;
int i,
    

    • 

  • vagrant学习笔记
dcj3sjt126com
vagrant

    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant
 
1. vagrant virtualbox 下载安装
https://www.vagrantup.com/downloads.html
https://www.virtualbox.org/wiki/Downloads
 
查看安装在命令行输入vagrant
 
 
2.
    

    • 

  • 14.性能优化-优化-软件配置优化
frank1234
软件配置性能优化

    1.Tomcat线程池
修改tomcat的server.xml文件：
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
    

    • 

  • 一个不错的shell 脚本教程 入门级
HarborChung
linuxshell

    一个不错的shell 脚本教程 入门级
建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
    

    • 

  • Spring4新特性——核心容器的其他改进
jinnianshilongnian
spring动态代理spring4依赖注入

    Spring4新特性——泛型限定式依赖注入
Spring4新特性——核心容器的其他改进
Spring4新特性——Web开发的增强
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC 
Spring4新特性——Groovy Bean定义DSL
Spring4新特性——更好的Java泛型操作API 
Spring4新
    

    • 

  • Linux设置tomcat开机启动
liuxingguome
tomcatlinux开机自启动

    执行命令sudo gedit /etc/init.d/tomcat6
然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。
#!/bin/bash
#
# /etc/rc.d/init.d/tomcat
# init script for tomcat precesses
    

    • 

  • 第13章 Ajax进阶（下）
onestopweb
Ajax

    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/
    

    • 

  • Troubleshooting Crystal Reports off BW
blueoxygen
BO

    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE
 
Quite useful, especially this part:
SAP BW connectivity
For t
    

    • 

  • Java开发熟手该当心的11个错误
tomcat_oracle
javajvm多线程单元测试

    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    

    • 

  • 正则表达式大全
yang852220741
html编程正则表达式

    今天向大家分享正则表达式大全，它可以大提高你的工作效率
正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。
一、校验数字的表达式
数字：^[0-9]*$
n位的数字：^\d{n}$
至少n位的数字：^\d{n,}$
m-n位的数字：^\d{m,n}$
    

    •