spring注解和xml方式区别详解

时间:2022-09-24 14:50:05

一。spring常规方式。

在使用注释配置之前,先来回顾一下传统上是如何配置 Bean 并完成 Bean 之间依赖关系的建立。下面是 3 个类,它们分别是 Office、Car 和 Boss,这 3 个类需要在 Spring 容器中配置为 Bean:

Office 仅有一个属性:

清单 1. Office.java

  1. package com.baobaotao;
  2. public class Office {
  3. private String officeNo =”001”;
  4. //省略 get/setter
  5. @Override
  6. public String toString() {
  7. return "officeNo:" + officeNo;
  8. }
  9. }

Car 拥有两个属性:

清单 2. Car.java

  1. package com.baobaotao;
  2. public class Car {
  3. private String brand;
  4. private double price;
  5. // 省略 get/setter
  6. @Override
  7. public String toString() {
  8. return "brand:" + brand + "," + "price:" + price;
  9. }
  10. }

Boss 拥有 Office 和 Car 类型的两个属性:

清单 3. Boss.java

  1. package com.baobaotao;
  2. public class Boss {
  3. private Car car;
  4. private Office office;
  5. // 省略 get/setter
  6. @Override
  7. public String toString() {
  8. return "car:" + car + "\n" + "office:" + office;
  9. }
  10. }

我们在 Spring 容器中将 Office 和 Car 声明为 Bean,并注入到 Boss Bean 中:下面是使用传统 XML 完成这个工作的配置文件 beans.xml:

清单 4. beans.xml 将以上三个类配置成 Bean

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <bean id="boss" class="com.baobaotao.Boss">
  7. <property name="car" ref="car"/>
  8. <property name="office" ref="office" />
  9. </bean>
  10. <bean id="office" class="com.baobaotao.Office">
  11. <property name="officeNo" value="002"/>
  12. </bean>
  13. <bean id="car" class="com.baobaotao.Car" scope="singleton">
  14. <property name="brand" value=" 红旗 CA72"/>
  15. <property name="price" value="2000"/>
  16. </bean>
  17. </beans>

当我们运行以下代码时,控制台将正确打出 boss 的信息:

清单 5. 测试类:AnnoIoCTest.java

  1. import org.springframework.context.ApplicationContext;
  2. import org.springframework.context.support.ClassPathXmlApplicationContext;
  3. public class AnnoIoCTest {
  4. public static void main(String[] args) {
  5. String[] locations = {"beans.xml"};
  6. ApplicationContext ctx =
  7. new ClassPathXmlApplicationContext(locations);
  8. Boss boss = (Boss) ctx.getBean("boss");
  9. System.out.println(boss);
  10. }
  11. }

这说明 Spring 容器已经正确完成了 Bean 创建和装配的工作。

二,使用注解注入属性

使用 @Autowired 注释

Spring 2.5 引入了 @Autowired 注释,它可以对类成员变量、方法及构造函数进行标注,完成自动装配的工作。来看一下使用@Autowired 进行成员变量自动注入的代码:

清单 6. 使用 @Autowired 注释的 Boss.java

  1. package com.baobaotao;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. public class Boss {
  4. @Autowired
  5. private Car car;
  6. @Autowired
  7. private Office office;
  8. }

Spring 通过一个 BeanPostProcessor 对 @Autowired 进行解析,所以要让 @Autowired 起作用必须事先在 Spring 容器中声明AutowiredAnnotationBeanPostProcessor Bean。

清单 7. 让 @Autowired 注释工作起来

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <!-- 该 BeanPostProcessor 将自动起作用,对标注 @Autowired 的 Bean 进行自动注入 -->
  7. <bean class="org.springframework.beans.factory.annotation.
  8. AutowiredAnnotationBeanPostProcessor"/>
  9. <!-- 移除 boss Bean 的属性注入配置的信息 -->
  10. <bean id="boss" class="com.baobaotao.Boss"/>
  11. <bean id="office" class="com.baobaotao.Office">
  12. <property name="officeNo" value="001"/>
  13. </bean>
  14. <bean id="car" class="com.baobaotao.Car" scope="singleton">
  15. <property name="brand" value=" 红旗 CA72"/>
  16. <property name="price" value="2000"/>
  17. </bean>
  18. </beans>

这样,当 Spring 容器启动时,AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean,当发现 Bean 中拥有@Autowired 注释时就找到和其匹配(默认按类型匹配)的 Bean,并注入到对应的地方中去。

按照上面的配置,Spring 将直接采用 Java 反射机制对 Boss 中的 car 和 office 这两个私有成员变量进行自动注入。所以对成员变量使用 @Autowired 后,您大可将它们的 setter 方法(setCar() 和 setOffice())从 Boss 中删除。

当然,您也可以通过 @Autowired 对方法或构造函数进行标注,来看下面的代码:

清单 8. 将 @Autowired 注释标注在 Setter 方法上

  1. package com.baobaotao;
  2. public class Boss {
  3. private Car car;
  4. private Office office;
  5. @Autowired
  6. public void setCar(Car car) {
  7. this.car = car;
  8. }
  9. @Autowired
  10. public void setOffice(Office office) {
  11. this.office = office;
  12. }
  13. }

这时,@Autowired 将查找被标注的方法的入参类型的 Bean,并调用方法自动注入这些 Bean。而下面的使用方法则对构造函数进行标注:

清单 9. 将 @Autowired 注释标注在构造函数上

  1. package com.baobaotao;
  2. public class Boss {
  3. private Car car;
  4. private Office office;
  5. @Autowired
  6. public Boss(Car car ,Office office){
  7. this.car = car;
  8. this.office = office ;
  9. }
  10. }

由于 Boss() 构造函数有两个入参,分别是 car 和 office@Autowired 将分别寻找和它们类型匹配的 Bean,将它们作为 Boss(Car car ,Office office) 的入参来创建 Boss Bean。

如果 Spring 容器中拥有多个候选 Bean,Spring 容器在启动时也会抛出BeanCreationException 异常。来看下面的例子:

清单 12. 在 beans.xml 中配置两个 Office 类型的 Bean

  1. <bean id="office" class="com.baobaotao.Office">
  2. <property name="officeNo" value="001"/>
  3. </bean>
  4. <bean id="office2" class="com.baobaotao.Office">
  5. <property name="officeNo" value="001"/>
  6. </bean>

我们在 Spring 容器中配置了两个类型为 Office 类型的 Bean,当对 Boss 的 office 成员变量进行自动注入时,Spring 容器将无法确定到底要用哪一个 Bean,因此异常发生了。

Spring 允许我们通过 @Qualifier 注释指定注入 Bean 的名称,这样歧义就消除了,可以通过下面的方法解决异常:

清单 13. 使用 @Qualifier 注释指定注入 Bean 的名称

  1. @Autowired
  2. public void setOffice(@Qualifier("office")Office office) {
  3. this.office = office;
  4. }

@Qualifier("office") 中的 office 是 Bean 的名称,所以 @Autowired 和 @Qualifier 结合使用时,自动注入的策略就从 byType 转变成 byName 了。@Autowired 可以对成员变量、方法以及构造函数进行注释,而 @Qualifier 的标注对象是成员变量、方法入参、构造函数入参。正是由于注释对象的不同,所以 Spring 不将 @Autowired 和 @Qualifier 统一成一个注释类。下面是对成员变量和构造函数入参进行注释的代码:

对成员变量进行注释:

清单 14. 对成员变量使用 @Qualifier 注释

  1. public class Boss {
  2. @Autowired
  3. private Car car;
  4. @Autowired
  5. @Qualifier("office")
  6. private Office office;
  7. }

对构造函数入参进行注释:

清单 15. 对构造函数变量使用 @Qualifier 注释

  1. public class Boss {
  2. private Car car;
  3. private Office office;
  4. @Autowired
  5. public Boss(Car car , @Qualifier("office")Office office){
  6. this.car = car;
  7. this.office = office ;
  8. }
  9. }

@Qualifier 只能和 @Autowired 结合使用,是对 @Autowired 有益的补充。一般来讲,@Qualifier 对方法签名中入参进行注释会降低代码的可读性,而对成员变量注释则相对好一些。

使用 JSR-250 的注释

Spring 不但支持自己定义的 @Autowired 的注释,还支持几个由 JSR-250 规范定义的注释,它们分别是 @Resource@PostConstruct以及 @PreDestroy

@Resource

@Resource 的作用相当于 @Autowired,只不过 @Autowired 按 byType 自动注入,面 @Resource 默认按 byName 自动注入罢了。@Resource 有两个属性是比较重要的,分别是 name 和 type,Spring 将 @Resource 注释的 name 属性解析为 Bean 的名字,而 type 属性则解析为 Bean 的类型。所以如果使用 name 属性,则使用 byName 的自动注入策略,而使用 type 属性时则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性,这时将通过反射机制使用 byName 自动注入策略。

Resource 注释类位于 Spring 发布包的 lib/j2ee/common-annotations.jar 类包中,因此在使用之前必须将其加入到项目的类库中。来看一个使用 @Resource 的例子:

清单 16. 使用 @Resource 注释的 Boss.java

  1. package com.baobaotao;
  2. import javax.annotation.Resource;
  3. public class Boss {
  4. // 自动注入类型为 Car 的 Bean
  5. @Resource
  6. private Car car;
  7. // 自动注入 bean 名称为 office 的 Bean
  8. @Resource(name = "office")
  9. private Office office;
  10. }

一般情况下,我们无需使用类似于 @Resource(type=Car.class) 的注释方式,因为 Bean 的类型信息可以通过 Java 反射从代码中获取。

要让 JSR-250 的注释生效,除了在 Bean 类中标注这些注释外,还需要在 Spring 容器中注册一个负责处理这些注释的BeanPostProcessor

  1. <bean
  2. class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>

CommonAnnotationBeanPostProcessor 实现了 BeanPostProcessor 接口,它负责扫描使用了 JSR-250 注释的 Bean,并对它们进行相应的操作。

@PostConstruct 和 @PreDestroy

Spring 容器中的 Bean 是有生命周期的,Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作,您既可以通过实现 InitializingBean/DisposableBean 接口来定制初始化之后 / 销毁之前的操作方法,也可以通过 <bean> 元素的 init-method/destroy-method 属性指定初始化之后 / 销毁之前调用的操作方法

通过以下的测试代码,您将可以看到 Bean 的初始化 / 销毁方法是如何被执行的:

清单 18. 测试类代码

  1. package com.baobaotao;
  2. import org.springframework.context.support.ClassPathXmlApplicationContext;
  3. public class AnnoIoCTest {
  4. public static void main(String[] args) {
  5. String[] locations = {"beans.xml"};
  6. ClassPathXmlApplicationContext ctx =
  7. new ClassPathXmlApplicationContext(locations);
  8. Boss boss = (Boss) ctx.getBean("boss");
  9. System.out.println(boss);
  10. ctx.destroy();// 关闭 Spring 容器,以触发 Bean 销毁方法的执行
  11. }
  12. }

使用 <context:annotation-config/> 简化配置

Spring 2.1 添加了一个新的 context 的 Schema 命名空间,该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的,它仅提供元数据信息。要使元数 据信息真正起作用,必须让负责处理这些元数据的处理器工作起来。

而我们前面所介绍的 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor 就是处理这些注释元数据的处理器。但是直接在 Spring 配置文件中定义这些 Bean 显得比较笨拙。Spring 为我们提供了一种方便的注册这些BeanPostProcessor 的方式,这就是 <context:annotation-config/>。请看下面的配置:

清单 19. 调整 beans.xml 配置文件

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans
  6. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  7. http://www.springframework.org/schema/context
  8. http://www.springframework.org/schema/context/spring-context-2.5.xsd">
  9. <context:annotation-config/>
  10. <bean id="boss" class="com.baobaotao.Boss"/>
  11. <bean id="office" class="com.baobaotao.Office">
  12. <property name="officeNo" value="001"/>
  13. </bean>
  14. <bean id="car" class="com.baobaotao.Car" scope="singleton">
  15. <property name="brand" value=" 红旗 CA72"/>
  16. <property name="price" value="2000"/>
  17. </bean>
  18. </beans>

<context:annotationconfig/> 将隐式地向 Spring 容器注册AutowiredAnnotationBeanPostProcessorCommonAnnotationBeanPostProcessorPersistenceAnnotationBeanPostProcessor 以及equiredAnnotationBeanPostProcessor 这 4 个 BeanPostProcessor。

在配置文件中使用 context 命名空间之前,必须在 <beans> 元素中声明 context 命名空间。

三,使用注解完成BEAN的定义

使用 @Component

虽然我们可以通过 @Autowired 或 @Resource 在 Bean 类中使用自动注入功能,但是 Bean 还是在 XML 文件中通过 <bean> 进行定义 —— 也就是说,在 XML 配置文件中定义 Bean,通过 @Autowired 或 @Resource 为 Bean 的成员变量、方法入参或构造函数入参提供自动注入的功能。能否也通过注释定义 Bean,从 XML 配置文件中完全移除 Bean 定义的配置呢?答案是肯定的,我们通过 Spring 2.5 提供的 @Component 注释就可以达到这个目标了。

下面,我们完全使用注释定义 Bean 并完成 Bean 之间装配:

清单 20. 使用 @Component 注释的 Car.java

  1. package com.baobaotao;
  2. import org.springframework.stereotype.Component;
  3. @Component
  4. public class Car {
  5. }

仅需要在类定义处,使用 @Component 注释就可以将一个类定义了 Spring 容器中的 Bean。下面的代码将 Office 定义为一个 Bean:

清单 21. 使用 @Component 注释的 Office.java

  1. package com.baobaotao;
  2. import org.springframework.stereotype.Component;
  3. @Component
  4. public class Office {
  5. private String officeNo = "001";
  6. }

这样,我们就可以在 Boss 类中通过 @Autowired 注入前面定义的 Car 和 Office Bean 了。

清单 22. 使用 @Component 注释的 Boss.java

  1. package com.baobaotao;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.beans.factory.annotation.Required;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.stereotype.Component;
  6. @Component("boss")
  7. public class Boss {
  8. @Autowired
  9. private Car car;
  10. @Autowired
  11. private Office office;
  12. }

@Component 有一个可选的入参,用于指定 Bean 的名称,在 Boss 中,我们就将 Bean 名称定义为“boss”。一般情况下,Bean 都是 singleton 的,需要注入 Bean 的地方仅需要通过 byType 策略就可以自动注入了,所以大可不必指定 Bean 的名称。

在使用 @Component 注释后,Spring 容器必须启用类扫描机制以启用注释驱动 Bean 定义和注释驱动 Bean 自动注入的策略。Spring 2.5 对 context 命名空间进行了扩展,提供了这一功能,请看下面的配置:

清单 23. 简化版的 beans.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans
  6. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  7. http://www.springframework.org/schema/context
  8. http://www.springframework.org/schema/context/spring-context-2.5.xsd">
  9. <context:component-scan base-package="com.baobaotao"/>
  10. </beans>

这里,所有通过 <bean> 元素定义 Bean 的配置内容已经被移除,仅需要添加一行 <context:component-scan/> 配置就解决所有问题了——Spring XML 配置文件得到了极致的简化(当然配置元数据还是需要的,只不过以注释形式存在罢了)。<context:component-scan/> 的 base-package 属性指定了需要扫描的类包,类包及其递归子包中所有的类都会被处理。

<context:component-scan/> 还允许定义过滤器将基包下的某些类纳入或排除。Spring 支持以下 4 种类型的过滤方式,通过下表说明:

表 1. 扫描过滤方式

过滤器类型 说明

注释 假如 com.baobaotao.SomeAnnotation 是一个注释类,我们可以将使用该注释的类过滤出来。
类名指定 通过全限定类名进行过滤,如您可以指定将 com.baobaotao.Boss 纳入扫描,而将 com.baobaotao.Car 排除在外。
正则表达式 通过正则表达式定义过滤的类,如下所示: com\.baobaotao\.Default.*
AspectJ 表达式 通过 AspectJ 表达式定义过滤的类,如下所示: com. baobaotao..*Service+

下面是一个简单的例子:

  1. <context:component-scan base-package="com.baobaotao">
  2. <context:include-filter type="regex"
  3. expression="com\.baobaotao\.service\..*"/>
  4. <context:exclude-filter type="aspectj"
  5. expression="com.baobaotao.util..*"/>
  6. </context:component-scan>

值得注意的是 <context:component-scan/> 配置项不但启用了对类包进行扫描以实施注释驱动 Bean 定义的功能,同时还启用了注释驱动自动注入的功能(即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor 和CommonAnnotationBeanPostProcessor),因此当使用 <context:component-scan/> 后,就可以将 <context:annotation-config/> 移除了。

默认情况下通过 @Component 定义的 Bean 都是 singleton 的,如果需要使用其它作用范围的 Bean,可以通过 @Scope 注释来达到目标,如以下代码所示:

清单 24. 通过 @Scope 指定 Bean 的作用范围

  1. package com.baobaotao;
  2. import org.springframework.context.annotation.Scope;
  3. @Scope("prototype")
  4. @Component("boss")
  5. public class Boss {
  6. }

这样,当从 Spring 容器中获取 boss Bean 时,每次返回的都是新的实例了。

采用具有特殊语义的注释

Spring 2.5 中除了提供 @Component 注释外,还定义了几个拥有特殊语义的注释,它们分别是:@Repository@Service 和@Controller。在目前的 Spring 版本中,这 3 个注释和 @Component 是等效的,但是从注释类的命名上,很容易看出这 3 个注释分别和持久层、业务层和控制层(Web 层)相对应。虽然目前这 3 个注释和 @Component 相比没有什么新意,但 Spring 将在以后的版本中为它们添加特殊的功能。所以,如果 Web 应用程序采用了经典的三层分层结构的话,最好在持久层、业务层和控制层分别采用@Repository@Service 和 @Controller 对分层中的类进行注释,而用 @Component 对那些比较中立的类进行注释。

小结

Spring 在 2.1 以后对注释配置提供了强力的支持,注释配置功能成为 Spring 2.5 的最大的亮点之一。合理地使用 Spring 2.5 的注释配置,可以有效减少配置的工作量,提高程序的内聚性。但是这并不意味着传统 XML 配置将走向消亡,在第三方类 Bean 的配置,以及那些诸如数据源、缓存池、持久层操作模板类、事务管理等内容的配置上,XML 配置依然拥有不可替代的地位。

<context:annotation-config> 和 <context:component-scan>的区别

<context:annotation-config> 是用于激活那些已经在spring容器里注册过的bean(无论是通过xml的方式还是通过package sanning的方式)上面的注解,是一个注解处理工具。

<context:component-scan>除了具有<context:annotation-config>的功能之外,<context:component-scan>还可以在指定的package下扫描以及注册javabean 。

转自:http://uule.iteye.com/blog/2102927

spring注解和xml方式区别详解的更多相关文章

  1. Spring注解 强大了个强大--详解注解方式

    好文章:http://tonyaction.blog.51cto.com/227462/83874/ http://www.ibm.com/developerworks/cn/java/j-lo-sp ...

  2. python模块的导入的两种方式区别详解

    Python 有两种导入模块的方法.两种都有用,你应该知道什么时候使用哪一种方法.一种方法,import module,另一种是from module import,下面是 from module i ...

  3. spring与hibernate注解及XML方式集成

    spring与hibernate注解及XML方式集成 Hibernate Xml方式 该种方式需要在sessionFactory中引入对应的hbm.xml文件,样例如下: <!-- spring ...

  4. 【Spring】——声明式事务配置详解

    项目中用到了spring的事务: @Transactional(rollbackFor = Exception.class, transactionManager = "zebraTrans ...

  5. ssh2的application&period;xml配置文件配置详解

    ssh2的application.xml配置文件配置详解   1.导入其他的配置文件.在ssh项目中可以导入其他的配置文件,导入的格式为: <import resource="clas ...

  6. Spring全家桶——SpringBoot之AOP详解

    Spring全家桶--SpringBoot之AOP详解 面向方面编程(AOP)通过提供另一种思考程序结构的方式来补充面向对象编程(OOP). OOP中模块化的关键单元是类,而在AOP中,模块化单元是方 ...

  7. 基于Java的打包jar、war、ear包的作用与区别详解

      本篇文章,小编为大家介绍,基于Java的打包jar.war.ear包的作用与区别详解.需要的朋友参考下   以最终客户的角度来看,JAR文件就是一种封装,他们不需要知道jar文件中有多少个.cla ...

  8. HTTP POST GET 本质区别详解

    HTTP POST GET 本质区别详解 一 原理区别 一般在浏览器中输入网址访问资源都是通过GET方式:在FORM提交中,可以通过Method指定提交方式为GET或者POST,默认为GET提交 Ht ...

  9. 转-HTTP POST GET SOAP本质区别详解

    原文链接:HTTP POST GET SOAP本质区别详解 一 原理区别 一般在浏览器中输入网址访问资源都是通过GET方式:在FORM提交中,可以通过Method指定提交方式为GET或者POST,默认 ...

随机推荐

  1. iOS 钥匙串 指纹识别 get和Post请求的区别

    01-钥匙串 1. 通过系统提供的钥匙串功能可以在本地保存密码,系统使用AES的方式对密码加密 a. 查看Safari中保存的密码 2. 使用第三方框架SSKeychain把密码保存到钥匙串和获取钥匙 ...

  2. 使用appium做安卓手机web自动化测试 真机demo

    一:appium相关环境搭建过程略. 二:连接真机: 1.手机(andriod 4.2.2)连接电脑,打开USB调试模式. 2.运行cmd 输入 adb devices -l 查看UDID,如图: 3 ...

  3. 第01讲- Android背景知识

    第01讲Android背景知识 Android是基于Linux系统 Android系统框图 : 第一.操作系统层(OS) 第二.各种库(Libraries)和Android 运行环境(RunTime) ...

  4. Ajax获取Response头信息

    $.ajax({ type: 'HEAD', // 获取头信息,type=HEAD即可 url : window.location.href, complete: function( xhr,data ...

  5. 【转载】C&num; 字符串截取

    https://blog.csdn.net/maba007/article/details/78424760

  6. Learning-Python【23】:面向对象三大特性

    继承 封装 多态

  7. Arduino通过I2C&lpar;SSD1306&rpar;驱动0&period;96寸12864OLED

    I2C驱动的128x64 OLED I2C (Inter-Integrated Circuit) 集成电路总线是I2CBus的简称, 是一种串行通信总线, 使用多主从架构. 飞利浦公司在1980年代为 ...

  8. 微信支付服务器CA证书更换服务器安装der证书的方法 DigiCert的根证书

    [重要]微信支付服务器证书更换通知,请开发人员验证以免影响交易 尊敬的微信支付商户&服务商: 因微信支付HTTPS服务器证书的根CA证书将于2018年8月23日到期失效,微信支付计划于2018 ...

  9. C&num;-StructLayoutAttribute&lpar;结构体布局&rpar;

    struct实例字段的内存布局(Layout)和大小(Size) 在C/C++中,struct类型中的成员的一旦声明,则实例中成员在内存中的布局(Layout)顺序就定下来了,即与成员声明的顺序相同, ...

  10. 【ZJOI 2008】 生日聚会

    [题目链接] 点击打开链接 [算法] 动态规划 f[i][j][x][y]表示当前选了i个男生,j个女生,男生与女生差最大为x,女生与男生差最大为y的方案数 转移很显然,笔者不再赘述 [代码] #in ...